Modules/devinfo/soldevicetypes.cpp

0001 /*
0002  *  SPDX-FileCopyrightText: 2009 David Hubner <hubnerd@ntlworld.com>
0003  *
0004  *  SPDX-License-Identifier: GPL-2.0-or-later
0005  *
0006  */
0007
0008 #include "soldevicetypes.h"
0009
0010 #include <solid/battery.h>
0011 #include <solid/camera.h>
0012 #include <solid/deviceinterface.h>
0013 #include <solid/portablemediaplayer.h>
0014 #include <solid/processor.h>
0015 #include <solid/storageaccess.h>
0016 #include <solid/storagedrive.h>
0017 #include <solid/storagevolume.h>
0018
0019 #include <QProgressBar>
0020 #include <QStorageInfo>
0021
0022 // kde
0023 #include <KCapacityBar>
0024 #include <KFormat>
0025
0026 #include "qvlistlayout.h"
0027
0028 // ---- Processor
0029
0030 SolProcessorDevice::SolProcessorDevice(QTreeWidgetItem *parent, const Solid::Device &device)
0031     : SolDevice(parent, device)
0032 {
0033     deviceTypeHolder = Solid::DeviceInterface::Processor;
0034     setDefaultDeviceText();
0035 }
0036
0037 SolProcessorDevice::SolProcessorDevice(const Solid::DeviceInterface::Type &type)
0038     : SolDevice(type)
0039 {
0040     deviceTypeHolder = Solid::DeviceInterface::Processor;
0041
0042     setDeviceIcon(QIcon::fromTheme(QStringLiteral("cpu")));
0043     setDeviceText(i18n("Processors"));
0044     setDefaultListing(type);
0045 }
0046
0047 void SolProcessorDevice::setDefaultListing(const Solid::DeviceInterface::Type &type)
0048 {
0049     createDeviceChildren<SolProcessorDevice>(this, QString(), type);
0050 }
0051
0052 void SolProcessorDevice::setDefaultDeviceText()
0053 {
0054     const Solid::Processor *prodev = interface<const Solid::Processor>();
0055
0056     if (!prodev) {
0057         return;
0058     }
0059     setText(0, i18n("Processor %1", QString::number(prodev->number())));
0060 }
0061
0062 QVListLayout *SolProcessorDevice::infoPanelLayout()
0063 {
0064     QStringList labels;
0065     const Solid::Processor *prodev = interface<const Solid::Processor>();
0066
0067     if (!prodev) {
0068         return nullptr;
0069     }
0070     deviceInfoLayout = new QVListLayout();
0071
0072     QStringList extensions;
0073     const Solid::Processor::InstructionSets insSets = prodev->instructionSets();
0074
0075     if (insSets & Solid::Processor::IntelMmx) {
0076         extensions << i18n("Intel MMX");
0077     }
0078     if (insSets & Solid::Processor::IntelSse) {
0079         extensions << i18n("Intel SSE");
0080     }
0081     if (insSets & Solid::Processor::IntelSse2) {
0082         extensions << i18n("Intel SSE2");
0083     }
0084     if (insSets & Solid::Processor::IntelSse3) {
0085         extensions << i18n("Intel SSE3");
0086     }
0087     if (insSets & Solid::Processor::IntelSsse3) {
0088         extensions << i18n("Intel SSSE3");
0089     }
0090     if (insSets & Solid::Processor::IntelSse41) {
0091         extensions << i18n("Intel SSE4.1");
0092     }
0093     if (insSets & Solid::Processor::IntelSse42) {
0094         extensions << i18n("Intel SSE4.2");
0095     }
0096     if (insSets & Solid::Processor::Amd3DNow) {
0097         extensions << i18n("AMD 3DNow!");
0098     }
0099     if (insSets & Solid::Processor::AltiVec) {
0100         extensions << i18n("ATI IVEC");
0101     }
0102     if (extensions.isEmpty()) {
0103         extensions << i18nc("no instruction set extensions", "None");
0104     }
0105
0106     labels << i18n("Processor Number: ") << InfoPanel::friendlyString(QString::number(prodev->number())) << i18n("Max Speed: ")
0107            << InfoPanel::friendlyString(QString::number(prodev->maxSpeed())) << i18n("Supported Instruction Sets: ") << extensions.join(QLatin1String("\n"));
0108
0109     deviceInfoLayout->applyQListToLayout(labels);
0110     return deviceInfoLayout;
0111 }
0112
0113 // ---- Storage
0114
0115 SolStorageDevice::SolStorageDevice(QTreeWidgetItem *parent, const Solid::Device &device, const storageChildren &c)
0116     : SolDevice(parent, device)
0117 {
0118     deviceTypeHolder = Solid::DeviceInterface::StorageDrive;
0119     setDefaultDeviceText();
0120
0121     if (c == CREATECHILDREN) {
0122         createDeviceChildren<SolVolumeDevice>(this, device.udi(), Solid::DeviceInterface::StorageVolume);
0123     }
0124 }
0125
0126 SolStorageDevice::SolStorageDevice(const Solid::DeviceInterface::Type &type)
0127     : SolDevice(type)
0128 {
0129     deviceTypeHolder = Solid::DeviceInterface::StorageDrive;
0130
0131     setDeviceIcon(QIcon::fromTheme(QStringLiteral("drive-harddisk")));
0132     setDeviceText(i18n("Storage Drives"));
0133     setDefaultListing(type);
0134 }
0135
0136 void SolStorageDevice::setDefaultListing(const Solid::DeviceInterface::Type &type)
0137 {
0138     createDeviceChildren<SolStorageDevice>(this, QString(), type);
0139 }
0140
0141 void SolStorageDevice::setDefaultDeviceText()
0142 {
0143     const Solid::StorageDrive *stodev = interface<const Solid::StorageDrive>();
0144     if (!stodev) {
0145         return;
0146     }
0147
0148     QString storageType;
0149     switch (stodev->driveType()) {
0150     case Solid::StorageDrive::HardDisk:
0151         storageType = i18n("Hard Disk Drive");
0152         break;
0153     case Solid::StorageDrive::CompactFlash:
0154         storageType = i18n("Compact Flash Reader");
0155         break;
0156     case Solid::StorageDrive::SmartMedia:
0157         storageType = i18n("Smart Media Reader");
0158         break;
0159     case Solid::StorageDrive::SdMmc:
0160         storageType = i18n("SD/MMC Reader");
0161         break;
0162     case Solid::StorageDrive::CdromDrive:
0163         storageType = i18n("Optical Drive");
0164         break;
0165     case Solid::StorageDrive::MemoryStick:
0166         storageType = i18n("Memory Stick Reader");
0167         break;
0168     case Solid::StorageDrive::Xd:
0169         storageType = i18n("xD Reader");
0170         break;
0171     default:
0172         storageType = i18n("Unknown Drive");
0173     }
0174
0175     QString deviceText = storageType;
0176     setDeviceText(deviceText);
0177 }
0178
0179 QVListLayout *SolStorageDevice::infoPanelLayout()
0180 {
0181     QStringList labels;
0182     const Solid::StorageDrive *stodev = interface<const Solid::StorageDrive>();
0183
0184     if (!stodev) {
0185         return nullptr;
0186     }
0187     deviceInfoLayout = new QVListLayout();
0188
0189     QString bus;
0190     switch (stodev->bus()) {
0191     case Solid::StorageDrive::Ide:
0192         bus = i18n("IDE");
0193         break;
0194     case Solid::StorageDrive::Usb:
0195         bus = i18n("USB");
0196         break;
0197     case Solid::StorageDrive::Ieee1394:
0198         bus = i18n("IEEE1394");
0199         break;
0200     case Solid::StorageDrive::Scsi:
0201         bus = i18n("SCSI");
0202         break;
0203     case Solid::StorageDrive::Sata:
0204         bus = i18n("SATA");
0205         break;
0206     case Solid::StorageDrive::Platform:
0207         bus = i18nc("platform storage bus", "Platform");
0208         break;
0209     default:
0210         bus = i18nc("unknown storage bus", "Unknown");
0211     }
0212
0213     labels << i18n("Bus: ") << bus << i18n("Hotpluggable?") << InfoPanel::convertTf(stodev->isHotpluggable()) << i18n("Removable?")
0214            << InfoPanel::convertTf(stodev->isRemovable());
0215
0216     deviceInfoLayout->applyQListToLayout(labels);
0217     return deviceInfoLayout;
0218 }
0219
0220 // ---- Volume
0221
0222 SolVolumeDevice::SolVolumeDevice(QTreeWidgetItem *parent, const Solid::Device &device)
0223     : SolDevice(parent, device)
0224 {
0225     deviceTypeHolder = Solid::DeviceInterface::StorageVolume;
0226 }
0227
0228 SolVolumeDevice::SolVolumeDevice(const Solid::DeviceInterface::Type &type)
0229     : SolDevice(type)
0230 {
0231     deviceTypeHolder = Solid::DeviceInterface::StorageVolume;
0232
0233     setDefaultListing(type);
0234 }
0235
0236 void SolVolumeDevice::setDefaultListing(const Solid::DeviceInterface::Type &type)
0237 {
0238     createDeviceChildren<SolVolumeDevice>(this, QString(), type);
0239 }
0240
0241 QVListLayout *SolVolumeDevice::infoPanelLayout()
0242 {
0243     QStringList labels;
0244     KCapacityBar *usageBar = nullptr;
0245
0246     const Solid::StorageVolume *voldev = interface<const Solid::StorageVolume>();
0247     const Solid::StorageAccess *accdev = interface<const Solid::StorageAccess>();
0248
0249     if (!voldev) {
0250         return nullptr;
0251     }
0252     deviceInfoLayout = new QVListLayout();
0253
0254     QString usage;
0255     switch (voldev->usage()) {
0256     case Solid::StorageVolume::Unused:
0257         usage = i18n("Unused");
0258         break;
0259     case Solid::StorageVolume::FileSystem:
0260         usage = i18n("File System");
0261         break;
0262     case Solid::StorageVolume::PartitionTable:
0263         usage = i18n("Partition Table");
0264         break;
0265     case Solid::StorageVolume::Raid:
0266         usage = i18n("Raid");
0267         break;
0268     case Solid::StorageVolume::Encrypted:
0269         usage = i18n("Encrypted");
0270         break;
0271     default:
0272         usage = i18nc("unknown volume usage", "Unknown");
0273     }
0274
0275     labels << i18n("File System Type: ") << InfoPanel::friendlyString(voldev->fsType()) << i18n("Label: ")
0276            << InfoPanel::friendlyString(voldev->label(), i18n("Not Set")) << i18n("Volume Usage: ") << usage << i18n("UUID: ")
0277            << InfoPanel::friendlyString(voldev->uuid());
0278
0279     if (accdev) {
0280         const QString mountPoint = accdev->filePath();
0281
0282         labels << QStringLiteral("--") << i18n("Mounted At: ") << InfoPanel::friendlyString(mountPoint, i18n("Not Mounted"));
0283
0284         if (!mountPoint.isEmpty()) {
0285             QStorageInfo storageInfo(mountPoint);
0286
0287             labels << i18n("Volume Space:");
0288
0289             usageBar = new KCapacityBar();
0290             qint64 size = 0;
0291             if (storageInfo.isValid() && storageInfo.isReady() && (size = storageInfo.bytesTotal()) > 0) {
0292                 const auto freeSpace = storageInfo.bytesFree();
0293                 const auto usedSpace = size - freeSpace;
0294                 const auto usedPercent = static_cast<int>((usedSpace * 100) / size);
0295                 usageBar->setValue(usedPercent);
0296                 usageBar->setText(i18nc("Available space out of total partition size (percent used)",
0297                                         "%1 free of %2 (%3% used)",
0298                                         KFormat().formatByteSize(freeSpace),
0299                                         KFormat().formatByteSize(size),
0300                                         usedPercent));
0301             } else {
0302                 usageBar->setValue(0);
0303                 usageBar->setText(i18n("No data available"));
0304             }
0305         }
0306     }
0307
0308     deviceInfoLayout->applyQListToLayout(labels);
0309     if (usageBar) {
0310         deviceInfoLayout->addWidget(usageBar);
0311     }
0312
0313     return deviceInfoLayout;
0314 }
0315
0316 // Media Player
0317
0318 SolMediaPlayerDevice::SolMediaPlayerDevice(QTreeWidgetItem *parent, const Solid::Device &device)
0319     : SolDevice(parent, device)
0320 {
0321     deviceTypeHolder = Solid::DeviceInterface::PortableMediaPlayer;
0322 }
0323
0324 SolMediaPlayerDevice::SolMediaPlayerDevice(const Solid::DeviceInterface::Type &type)
0325     : SolDevice(type)
0326 {
0327     deviceTypeHolder = Solid::DeviceInterface::PortableMediaPlayer;
0328
0329     setDeviceIcon(QIcon::fromTheme(QStringLiteral("multimedia-player")));
0330     setDeviceText(i18n("Multimedia Players"));
0331     setDefaultListing(type);
0332 }
0333
0334 void SolMediaPlayerDevice::setDefaultListing(const Solid::DeviceInterface::Type &type)
0335 {
0336     createDeviceChildren<SolMediaPlayerDevice>(this, QString(), type);
0337 }
0338
0339 QVListLayout *SolMediaPlayerDevice::infoPanelLayout()
0340 {
0341     QStringList labels;
0342     const Solid::PortableMediaPlayer *mpdev = interface<const Solid::PortableMediaPlayer>();
0343
0344     if (!mpdev) {
0345         return nullptr;
0346     }
0347     deviceInfoLayout = new QVListLayout();
0348
0349     labels << i18n("Supported Drivers: ") << mpdev->supportedDrivers() << i18n("Supported Protocols: ") << mpdev->supportedProtocols();
0350
0351     deviceInfoLayout->applyQListToLayout(labels);
0352     return deviceInfoLayout;
0353 }
0354
0355 // Camera
0356
0357 SolCameraDevice::SolCameraDevice(QTreeWidgetItem *parent, const Solid::Device &device)
0358     : SolDevice(parent, device)
0359 {
0360     deviceTypeHolder = Solid::DeviceInterface::Camera;
0361 }
0362
0363 SolCameraDevice::SolCameraDevice(const Solid::DeviceInterface::Type &type)
0364     : SolDevice(type)
0365 {
0366     deviceTypeHolder = Solid::DeviceInterface::Camera;
0367
0368     setDeviceIcon(QIcon::fromTheme(QStringLiteral("camera-web")));
0369     setDeviceText(i18n("Cameras"));
0370     setDefaultListing(type);
0371 }
0372
0373 void SolCameraDevice::setDefaultListing(const Solid::DeviceInterface::Type &type)
0374 {
0375     createDeviceChildren<SolCameraDevice>(this, QString(), type);
0376 }
0377
0378 QVListLayout *SolCameraDevice::infoPanelLayout()
0379 {
0380     QStringList labels;
0381     const Solid::Camera *camdev = interface<const Solid::Camera>();
0382
0383     if (!camdev) {
0384         return nullptr;
0385     }
0386     deviceInfoLayout = new QVListLayout();
0387
0388     labels << i18n("Supported Drivers: ") << camdev->supportedDrivers() << i18n("Supported Protocols: ") << camdev->supportedProtocols();
0389
0390     deviceInfoLayout->applyQListToLayout(labels);
0391     return deviceInfoLayout;
0392 }
0393
0394 // Battery
0395
0396 SolBatteryDevice::SolBatteryDevice(QTreeWidgetItem *parent, const Solid::Device &device)
0397     : SolDevice(parent, device)
0398 {
0399     deviceTypeHolder = Solid::DeviceInterface::Battery;
0400 }
0401
0402 SolBatteryDevice::SolBatteryDevice(const Solid::DeviceInterface::Type &type)
0403     : SolDevice(type)
0404 {
0405     deviceTypeHolder = Solid::DeviceInterface::Battery;
0406
0407     setDeviceIcon(QIcon::fromTheme(QStringLiteral("battery")));
0408     setDeviceText(i18n("Batteries"));
0409     setDefaultListing(type);
0410 }
0411
0412 void SolBatteryDevice::setDefaultListing(const Solid::DeviceInterface::Type &type)
0413 {
0414     createDeviceChildren<SolBatteryDevice>(this, QString(), type);
0415 }
0416
0417 QVListLayout *SolBatteryDevice::infoPanelLayout()
0418 {
0419     QStringList labels;
0420     const Solid::Battery *batdev = interface<const Solid::Battery>();
0421
0422     if (!batdev) {
0423         return nullptr;
0424     }
0425     deviceInfoLayout = new QVListLayout();
0426
0427     QString type;
0428     switch (batdev->type()) {
0429     case Solid::Battery::PdaBattery:
0430         type = i18n("PDA");
0431         break;
0432     case Solid::Battery::UpsBattery:
0433         type = i18n("UPS");
0434         break;
0435     case Solid::Battery::PrimaryBattery:
0436         type = i18n("Primary");
0437         break;
0438     case Solid::Battery::MouseBattery:
0439         type = i18n("Mouse");
0440         break;
0441     case Solid::Battery::KeyboardBattery:
0442         type = i18n("Keyboard");
0443         break;
0444     case Solid::Battery::KeyboardMouseBattery:
0445         type = i18n("Keyboard + Mouse");
0446         break;
0447     case Solid::Battery::CameraBattery:
0448         type = i18n("Camera");
0449         break;
0450     case Solid::Battery::PhoneBattery:
0451         type = i18n("Phone");
0452         break;
0453     case Solid::Battery::MonitorBattery:
0454         type = i18nc("Screen", "Monitor");
0455         break;
0456     case Solid::Battery::GamingInputBattery:
0457         type = i18nc("Wireless game pad or joystick battery", "Gaming Input");
0458         break;
0459     default:
0460         type = i18nc("unknown battery type", "Unknown");
0461     }
0462
0463     QString state;
0464     switch (batdev->chargeState()) {
0465     case Solid::Battery::Charging:
0466         state = i18n("Charging");
0467         break;
0468     case Solid::Battery::Discharging:
0469         state = i18n("Discharging");
0470         break;
0471     case Solid::Battery::FullyCharged:
0472         state = i18n("Fully Charged");
0473         break;
0474     default:
0475         state = i18n("No Charge");
0476     }
0477
0478     labels << i18n("Battery Type: ") << type << i18n("Charge Status: ") << state << i18n("Charge Percent: ");
0479
0480     deviceInfoLayout->applyQListToLayout(labels);
0481
0482     QProgressBar *chargePercent = new QProgressBar();
0483     chargePercent->setMaximum(100);
0484     chargePercent->setValue(batdev->chargePercent());
0485     chargePercent->setEnabled(batdev->isPresent());
0486
0487     deviceInfoLayout->addWidget(chargePercent);
0488
0489     return deviceInfoLayout;
0490 }