workspace/plasma/applets/system-monitor/hdd.cpp

   1 /*
   2  *   Copyright (C) 2007 Petri Damsten <damu@iki.fi>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License version 2 as
   6  *   published by the Free Software Foundation
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details
  12  *
  13  *   You should have received a copy of the GNU Library General Public
  14  *   License along with this program; if not, write to the
  15  *   Free Software Foundation, Inc.,
  16  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "hdd.h"
  20 #include "monitoricon.h"
  21 #include <Plasma/Meter>
  22 #include <Plasma/Containment>
  23 #include <Plasma/Theme>
  24 #include <KConfigDialog>
  25 #include <QFileInfo>
  26 #include <QGraphicsLinearLayout>
  27
  28 Hdd::Hdd(QObject *parent, const QVariantList &args)
  29     : SM::Applet(parent, args)
  30 {
  31     setHasConfigurationInterface(true);
  32     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
  33     connect(Plasma::Theme::defaultTheme(), SIGNAL(themeChanged()), this, SLOT(themeChanged()));
  34 }
  35
  36 Hdd::~Hdd()
  37 {
  38 }
  39
  40 void Hdd::init()
  41 {
  42     KConfigGroup cg = persistentConfig();
  43     QString predicateString("IS StorageVolume");
  44     setEngine(dataEngine("soliddevice"));
  45     setItems(cg.readEntry("uuids",
  46              engine()->query(predicateString)[predicateString].toStringList()));
  47     setInterval(cg.readEntry("interval", 2) * 60 * 1000);
  48
  49     setTitle(i18n("Disk Space"), true);
  50     connectToEngine();
  51 }
  52
  53 void Hdd::createConfigurationInterface(KConfigDialog *parent)
  54 {
  55     QWidget *widget = new QWidget();
  56     ui.setupUi(widget);
  57     m_hddModel.clear();
  58     m_hddModel.setHorizontalHeaderLabels(QStringList() << i18n("Mount Point")
  59                                                        << i18n("Name"));
  60     QStandardItem *parentItem = m_hddModel.invisibleRootItem();
  61     Plasma::DataEngine::Data data;
  62     QString predicateString("IS StorageVolume");
  63
  64     foreach (const QString& uuid, engine()->query(predicateString)[predicateString].toStringList()) {
  65         if (!isValidDevice(uuid, &data)) {
  66             continue;
  67         }
  68         QStandardItem *item1 = new QStandardItem(data["File Path"].toString());
  69         item1->setEditable(false);
  70         item1->setCheckable(true);
  71         item1->setData(uuid);
  72         if (items().contains(uuid)) {
  73             item1->setCheckState(Qt::Checked);
  74         }
  75         QStandardItem *item2 = new QStandardItem(title(uuid, data));
  76         item2->setEditable(true);
  77         parentItem->appendRow(QList<QStandardItem *>() << item1 << item2);
  78     }
  79     ui.treeView->setModel(&m_hddModel);
  80     ui.treeView->resizeColumnToContents(0);
  81     ui.intervalSpinBox->setValue(interval() / 60 / 1000);
  82
  83     parent->addPage(widget, i18n("Partitions"), "drive-harddisk");
  84     connect(parent, SIGNAL(applyClicked()), this, SLOT(configAccepted()));
  85     connect(parent, SIGNAL(okClicked()), this, SLOT(configAccepted()));
  86 }
  87
  88 void Hdd::configAccepted()
  89 {
  90     KConfigGroup cg = persistentConfig();
  91     QStandardItem *parentItem = m_hddModel.invisibleRootItem();
  92
  93     clearItems();
  94     for (int i = 0; i < parentItem->rowCount(); ++i) {
  95         QStandardItem *item = parentItem->child(i, 0);
  96         if (item) {
  97             cg.writeEntry(item->data().toString(),
  98                           parentItem->child(i, 1)->text());
  99             if (item->checkState() == Qt::Checked) {
 100                 appendItem(item->data().toString());
 101             }
 102         }
 103     }
 104     cg.writeEntry("uuids", items());
 105
 106     uint interval = ui.intervalSpinBox->value();
 107     cg.writeEntry("interval", interval);
 108     interval *= 60 * 1000;
 109     setInterval(interval);
 110
 111     emit configNeedsSaving();
 112     connectToEngine();
 113 }
 114
 115 QString Hdd::title(const QString& uuid, const Plasma::DataEngine::Data &data)
 116 {
 117     KConfigGroup cg = persistentConfig();
 118     QString label = cg.readEntry(uuid, "");
 119
 120     if (label.isEmpty()) {
 121         label = data["Label"].toString();
 122         if (label.isEmpty()) {
 123             QString path = data["File Path"].toString();
 124             if (path == "/")
 125                 return i18nc("the root filesystem", "root");
 126             QFileInfo fi(path);
 127             label = fi.fileName();
 128             if (label.isEmpty()) {
 129                 label = data["Device"].toString();
 130                 if (label.isEmpty()) {
 131                     kDebug() << "Disk: " << uuid << " has empty label";
 132                     label = i18n("Unknown filesystem");
 133                 }
 134             }
 135         }
 136     }
 137     QVariant accessible = data["Accessible"];
 138     if (accessible.isValid()) {
 139         if (accessible.canConvert(QVariant::Bool)) {
 140             if (!accessible.toBool()) {
 141                 label = i18nc("hard disk label (not mounted or accessible)",
 142                               "%1 (not accessible)", label);
 143             }
 144         }
 145     }
 146     return label;
 147 }
 148
 149 bool Hdd::addMeter(const QString& source)
 150 {
 151     Plasma::Meter *w;
 152     Plasma::DataEngine *engine = dataEngine("soliddevice");
 153     Plasma::DataEngine::Data data;
 154     Plasma::Theme* theme = Plasma::Theme::defaultTheme();
 155
 156     if (!engine) {
 157         return false;
 158     }
 159     if (!isValidDevice(source, &data)) {
 160         // do not try to show hard drives and swap partitions.
 161         return false;
 162     }
 163     QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal);
 164     layout->setContentsMargins(3, 3, 3, 3);
 165     layout->setSpacing(5);
 166
 167     w = new Plasma::Meter(this);
 168     w->setMeterType(Plasma::Meter::BarMeterHorizontal);
 169     if (mode() != SM::Applet::Panel) {
 170         MonitorIcon *icon = new MonitorIcon(this);
 171         m_icons.insert(source, icon);
 172         icon->setImage("drive-harddisk");
 173         if (data["Accessible"].toBool()) {
 174             QStringList overlays;
 175             overlays << QString("emblem-mounted");
 176             icon->setOverlays(overlays);
 177         }
 178         layout->addItem(icon);
 179     } else {
 180         w->setSvg("system-monitor/hdd_panel");
 181     }
 182     QColor text = theme->color(Plasma::Theme::TextColor);
 183     QColor background = theme->color(Plasma::Theme::BackgroundColor);
 184     QColor darkerText((text.red() + background.red()) / 2,
 185                       (text.green() + background.green()) / 2,
 186                       (text.blue() + background.blue()) / 2,
 187                       (text.alpha() + background.alpha()) / 2);
 188     w->setLabel(0, title(source, data));
 189     w->setLabelColor(0, text);
 190     w->setLabelColor(1, darkerText);
 191     w->setLabelColor(2, darkerText);
 192     QFont font = theme->font(Plasma::Theme::DefaultFont);
 193     font.setPointSize(9);
 194     w->setLabelFont(0, font);
 195     font.setPointSizeF(7.5);
 196     w->setLabelFont(1, font);
 197     w->setLabelFont(2, font);
 198     w->setLabelAlignment(0, Qt::AlignVCenter | Qt::AlignLeft);
 199     w->setLabelAlignment(1, Qt::AlignVCenter | Qt::AlignRight);
 200     w->setLabelAlignment(2, Qt::AlignVCenter | Qt::AlignCenter);
 201     w->setMaximum(data["Size"].toULongLong() / (1024 * 1024));
 202     layout->addItem(w);
 203     appendMeter(source, w);
 204     mainLayout()->addItem(layout);
 205     dataUpdated(source, data);
 206     setPreferredItemHeight(layout->preferredSize().height());
 207
 208     QString disk = data["Parent UDI"].toString();
 209
 210     m_diskMap[disk] << w;
 211     if (!connectedSources().contains(disk)) {
 212         data = engine->query(disk);
 213         dataUpdated(disk, data);
 214         connectSource(disk);
 215     }
 216     return true;
 217 }
 218
 219 void Hdd::themeChanged()
 220 {
 221     Plasma::Theme* theme = Plasma::Theme::defaultTheme();
 222     foreach (Plasma::Meter *w, meters().values()) {
 223         QColor text = theme->color(Plasma::Theme::TextColor);
 224         QColor background = theme->color(Plasma::Theme::BackgroundColor);
 225         QColor darkerText((text.red() + background.red()) / 2,
 226                           (text.green() + background.green()) / 2,
 227                           (text.blue() + background.blue()) / 2,
 228                           (text.alpha() + background.alpha()) / 2);
 229         w->setLabelColor(0, text);
 230         w->setLabelColor(1, darkerText);
 231         w->setLabelColor(2, darkerText);
 232         QFont font = theme->font(Plasma::Theme::DefaultFont);
 233         font.setPointSize(9);
 234         w->setLabelFont(0, font);
 235         font.setPointSizeF(7.5);
 236         w->setLabelFont(1, font);
 237         w->setLabelFont(2, font);
 238     }
 239 }
 240
 241 void Hdd::deleteMeters(QGraphicsLinearLayout* layout)
 242 {
 243     Applet::deleteMeters(layout);
 244     m_diskMap.clear();
 245 }
 246
 247 bool Hdd::isValidDevice(const QString& uuid, Plasma::DataEngine::Data* data)
 248 {
 249     Plasma::DataEngine *engine = dataEngine("soliddevice");
 250     if (engine) {
 251         *data = engine->query(uuid);
 252         /*
 253         kDebug() << uuid << data->value("Device").toString() <<
 254                             data->value("Usage").toString() <<
 255                             data->value("File System Type").toString() <<
 256                             data->value("Size").toString();
 257         */
 258         if ((data->value("Usage").toString() != "File System" &&
 259              data->value("Usage").toString() != "Raid") ||
 260             data->value("File System Type").toString() == "swap") {
 261             QStringList list = items();
 262             list.removeAll(uuid);
 263             setItems(list);
 264             return false;
 265         }
 266         return true;
 267     }
 268     return false;
 269 }
 270
 271 void Hdd::dataUpdated(const QString& source,
 272                       const Plasma::DataEngine::Data &data)
 273 {
 274     if (m_diskMap.keys().contains(source) && mode() != SM::Applet::Panel) {
 275         if (data.keys().contains("Temperature")) {
 276             QList<Plasma::Meter *> widgets = m_diskMap[source];
 277             foreach (Plasma::Meter *w, widgets) {
 278                 w->setLabel(2, QString("%1\xb0%2").arg(data["Temperature"].toString())
 279                                                   .arg(data["Temperature Unit"].toString()));
 280             }
 281         }
 282     } else {
 283         Plasma::Meter *w = meters().value(source);
 284         if (!w) {
 285             return;
 286         }
 287         qulonglong size = qulonglong(data["Size"].toULongLong() /
 288                           (1024 * 1024));
 289         qlonglong availBytes = 0;
 290         QVariant freeSpace = data["Free Space"];
 291         if (freeSpace.isValid()) {
 292             if (freeSpace.canConvert(QVariant::LongLong)) {
 293                 availBytes = qlonglong(freeSpace.toLongLong());
 294                 w->setValue(size - availBytes / (1024 * 1024));
 295             }
 296         }
 297         else {
 298             w->setValue(0);
 299         }
 300         if (mode() != SM::Applet::Panel) {
 301             w->setLabel(1, KGlobal::locale()->formatByteSize(availBytes));
 302             QStringList overlays;
 303             if (data["Accessible"].toBool()) {
 304                 overlays << "emblem-mounted";
 305             }
 306             m_icons[source]->setOverlays(overlays);
 307         }
 308     }
 309 }
 310
 311 #include "hdd.moc"