apps/kinfocenter/partition/kcm_partition.cpp

   1 /*
   2  *  Copyright (C) 2008 Nicolas Ternisien <nicolas.ternisien@gmail.com>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "kcm_partition.h"
  20
  21 #include <QStringList>
  22
  23 #include <KPluginFactory>
  24 #include <KPluginLoader>
  25
  26 #include <kaboutdata.h>
  27 #include <kdialog.h>
  28 #include <kdebug.h>
  29
  30 #include <QLayout>
  31 #include <QPainter>
  32
  33 #include <QPixmap>
  34 #include <QLabel>
  35 #include <QVBoxLayout>
  36 #include <QHBoxLayout>
  37 #include <QTreeWidget>
  38 #include <QTreeWidgetItemIterator>
  39
  40 #include <klocale.h>
  41 #include <kglobal.h>
  42 #include <kseparator.h>
  43 #include <kdiskfreespace.h>
  44
  45 #include <solid/device.h>
  46 #include <solid/deviceinterface.h>
  47
  48 #include "usedSizeWidget.h"
  49
  50 K_PLUGIN_FACTORY(KCMPartitionFactory,
  51                 registerPlugin<KCMPartition>();
  52 )
  53 K_EXPORT_PLUGIN(KCMPartitionFactory("kcm_partition"))
  54
  55 KCMPartition::KCMPartition(QWidget *parent, const QVariantList &) :
  56         KCModule(KCMPartitionFactory::componentData(), parent) {
  57
  58         KAboutData *about = new KAboutData(I18N_NOOP("kcm_partition"), 0,
  59                         ki18n("KDE Partitions Information Control Module"),
  60                         0, KLocalizedString(), KAboutData::License_GPL,
  61                         ki18n( "(c) 2008 Nicolas Ternisien"));
  62
  63         about->addAuthor(ki18n("Nicolas Ternisien"), KLocalizedString(), "nicolas.ternisien@gmail.com");
  64         setAboutData(about);
  65
  66         QHBoxLayout* layout = new QHBoxLayout(this);
  67         layout->setSpacing(0);
  68         layout->setMargin(0);
  69
  70         tree = new QTreeWidget(this);
  71         layout->addWidget(tree);
  72         tree->setSelectionMode(QAbstractItemView::ExtendedSelection);
  73         tree->setAllColumnsShowFocus(true);
  74         tree->setRootIsDecorated(true);
  75         tree->setAlternatingRowColors(true);
  76         tree->setSortingEnabled(true);
  77         tree->setWhatsThis(i18n("This list displays partitions of your system.") );
  78
  79         QStringList headers;
  80         headers << i18n("Mount Point") << i18n("Label") << i18n("Type") << i18n("Total Size") << i18n("Free Size") << i18n("Used Size");
  81         tree->setHeaderLabels(headers);
  82
  83 }
  84
  85 KCMPartition::~KCMPartition() {
  86
  87 }
  88
  89 void KCMPartition::load() {
  90         kDebug() << "Loading partition information..." << endl;
  91
  92         QMap<QString, QTreeWidgetItem*> rootDevicesItem;
  93
  94
  95         QList<Solid::Device> devices = Solid::Device::listFromType(Solid::DeviceInterface::StorageDrive, QString());
  96
  97         //Root Devices (Hard Disks, CD-Rom drives,...)
  98         foreach(const Solid::Device &device, devices) {
  99                 if(device.is<Solid::StorageDrive>() == false) {
 100                         continue;
 101                 }
 102
 103                 const Solid::StorageDrive* drive = device.as<Solid::StorageDrive>();
 104
 105                 QStringList itemContent;
 106
 107                 itemContent << i18nc("Device (Vendor)", "%1 (%2)", device.product(), device.vendor()) << findDriveType(drive) << findBusType(drive);
 108
 109                 QTreeWidgetItem* item = new QTreeWidgetItem(tree, itemContent);
 110                 item->setIcon(0, KIcon(device.icon()));
 111                 item->setExpanded(true);
 112
 113                 rootDevicesItem.insert(device.udi(), item);
 114         }
 115
 116         //Storage volumes
 117         QList<Solid::Device> storageVolumes = Solid::Device::listFromType(Solid::DeviceInterface::StorageVolume, QString());
 118         QList<QString> accessPaths;
 119
 120         foreach(const Solid::Device &device, storageVolumes) {
 121
 122                 if(device.is<Solid::StorageVolume>() == false) {
 123                         continue;
 124                 }
 125
 126                 const Solid::StorageVolume* volume = device.as<Solid::StorageVolume>();
 127
 128                 QStringList itemContent;
 129
 130                 if (device.is<Solid::StorageAccess>()) {
 131                         const Solid::StorageAccess* access = device.as<Solid::StorageAccess>();
 132                         itemContent << access->filePath();
 133
 134                         accessPaths.append(access->filePath());
 135                 }
 136                 else {
 137                         itemContent << i18n("none");
 138                 }
 139
 140                 itemContent << volume->label() << volume->fsType() << KGlobal::locale()->formatByteSize(volume->size());
 141
 142                 QTreeWidgetItem* item;
 143                 if (rootDevicesItem.contains(device.parentUdi())) {
 144                         QTreeWidgetItem* root = rootDevicesItem.value(device.parentUdi());
 145
 146                         item = new QTreeWidgetItem(root, itemContent);
 147                 }
 148                 else {
 149                         item = new QTreeWidgetItem(tree, itemContent);
 150                 }
 151
 152                 item->setIcon(0, KIcon(device.icon()));
 153                 item->setTextAlignment(TOTAL_SIZE_INDEX, Qt::AlignRight);
 154                 item->setTextAlignment(FREE_SIZE_INDEX, Qt::AlignRight);
 155
 156                 UsedSizeWidget* usedSizeWidget = new UsedSizeWidget(tree);
 157                 usedSizeWidget->setObjectName(device.udi());
 158                 tree->setItemWidget(item, USED_SIZE_INDEX, usedSizeWidget);
 159
 160                 /*
 161                 UsedSizeWidget* otherUsedSizeWidget = (UsedSizeWidget*) tree->itemWidget(item, USED_SIZE_INDEX);
 162                 if (otherUsedSizeWidget==NULL) {
 163                         kError() << "BUG BUG BUG !!! Just added used size widget of " << itemContent << " is null !!!" << endl;
 164                 }
 165                 */
 166
 167         }
 168
 169         resizeContent();
 170
 171         tree->sortItems(0, Qt::AscendingOrder);
 172
 173         //Do this later to be sure all UsedSizeWidget will be ready
 174         foreach(const QString &accessPath, accessPaths) {
 175                 connect(KDiskFreeSpace::findUsageInfo(accessPath), SIGNAL(foundMountPoint (const QString&, quint64, quint64, quint64)), this, SLOT(mountPointInfo(const QString&, quint64, quint64, quint64)) );
 176         }
 177
 178 }
 179
 180 QString KCMPartition::findBusType(const Solid::StorageDrive* drive) const {
 181         switch (drive->bus()) {
 182         case Solid::StorageDrive::Ide:
 183                 return i18n("IDE");
 184         case Solid::StorageDrive::Usb:
 185                 return i18n("USB");
 186         case Solid::StorageDrive::Ieee1394:
 187                 return i18n("IEEE 1394");
 188         case Solid::StorageDrive::Scsi:
 189                 return i18n("SCSI");
 190         case Solid::StorageDrive::Sata:
 191                 return i18n("S-ATA");
 192         case Solid::StorageDrive::Platform:
 193                 return i18n("Platform");
 194         }
 195
 196         return i18n("Unknown Bus");
 197 }
 198
 199 QString KCMPartition::findDriveType(const Solid::StorageDrive* drive) const {
 200         switch (drive->driveType()) {
 201         case Solid::StorageDrive::HardDisk:
 202                 return i18n("Hard Disk");
 203         case Solid::StorageDrive::CdromDrive:
 204                 return i18n("CD/DVD Drive");
 205         case Solid::StorageDrive::Floppy:
 206                 return i18n("Floppy Drive");
 207         case Solid::StorageDrive::Tape:
 208                 return i18n("Tape");
 209         case Solid::StorageDrive::CompactFlash:
 210                 return i18n("Compact Flash");
 211         case Solid::StorageDrive::MemoryStick:
 212                 return i18n("Memory Stick");
 213         case Solid::StorageDrive::SmartMedia:
 214                 return i18n("Smart Media");
 215         case Solid::StorageDrive::SdMmc:
 216                 return i18n("SD/MMC");
 217         case Solid::StorageDrive::Xd:
 218                 return i18n("Xd");
 219         }
 220
 221         return i18n("Unknown Type");
 222 }
 223
 224 QString KCMPartition::quickHelp() const {
 225         return i18n("This display shows information about partitions and hard disks of your system.");
 226 }
 227
 228 void KCMPartition::mountPointInfo(const QString& mountPoint, quint64 kibSize, quint64 kibUsed, quint64 kibAvail) {
 229
 230         QTreeWidgetItemIterator it(tree, QTreeWidgetItemIterator::All);
 231         while ( *it != NULL ) {
 232                 QTreeWidgetItem* currentItem = *it;
 233
 234                 if (currentItem->text(0) == mountPoint) {
 235                         currentItem->setText(TOTAL_SIZE_INDEX, KGlobal::locale()->formatByteSize(kibSize*1000));
 236                         currentItem->setText(FREE_SIZE_INDEX, KGlobal::locale()->formatByteSize(kibAvail*1000));
 237
 238                         UsedSizeWidget* usedSizeWidget = (UsedSizeWidget*) tree->itemWidget(currentItem, USED_SIZE_INDEX);
 239
 240                         if (usedSizeWidget!=NULL) {
 241                                 usedSizeWidget->setUsedSize(mountPoint, kibSize*1000, kibUsed*1000, kibAvail*1000);
 242                         }
 243                         /*
 244                         else {
 245                                 kError() << "BUG BUG BUG AGAIN !!! Used Size Widget null for " << mountPoint << endl;
 246                         }
 247                         */
 248
 249                         resizeContent();
 250
 251                         break;
 252                 }
 253
 254                 ++it;
 255         }
 256
 257         resizeContent();
 258
 259
 260 }
 261
 262 void KCMPartition::resizeContent() const {
 263         for(int i=0; i<tree->columnCount(); ++i) {
 264                 tree->resizeColumnToContents(i);
 265         }
 266 }
 267
 268 #include "kcm_partition.moc"