You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2123 lines
51 KiB
2123 lines
51 KiB
/* This file is part of the TDE libraries
|
|
Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License version 2 as published by the Free Software Foundation.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
#ifndef _TDEHARDWAREDEVICES_H
|
|
#define _TDEHARDWAREDEVICES_H
|
|
|
|
// TDE includes
|
|
#include <tqobject.h>
|
|
#include <tqstring.h>
|
|
#include <tqptrlist.h>
|
|
#include <tqstringlist.h>
|
|
#include "kiconloader.h"
|
|
#include "tdelibs_export.h"
|
|
|
|
// udev includes
|
|
#include <libudev.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <locale.h>
|
|
#include <unistd.h>
|
|
|
|
/**
|
|
* Hardware Device Access and Monitoring Library
|
|
*
|
|
* @author Timothy Pearson
|
|
*/
|
|
|
|
class TDENetworkConnectionManager;
|
|
|
|
namespace TDEHardwareEvent {
|
|
enum TDEHardwareEvent {
|
|
HardwareListModified,
|
|
MountTableModified,
|
|
HardwareAdded,
|
|
HardwareRemoved,
|
|
HardwareUpdated,
|
|
Other,
|
|
Last = Other
|
|
};
|
|
};
|
|
|
|
// Keep readGenericDeviceTypeFromString(), getFriendlyDeviceTypeStringFromType(), and getDeviceTypeIconFromType() in tdehardwaredevices.cpp in sync with this enum
|
|
namespace TDEGenericDeviceType {
|
|
enum TDEGenericDeviceType {
|
|
Root,
|
|
RootSystem,
|
|
CPU,
|
|
GPU,
|
|
RAM,
|
|
Bus,
|
|
I2C,
|
|
MDIO,
|
|
Mainboard,
|
|
Disk,
|
|
SCSI,
|
|
StorageController,
|
|
Mouse,
|
|
Keyboard,
|
|
HID,
|
|
Modem,
|
|
Monitor,
|
|
Network,
|
|
Printer,
|
|
Scanner,
|
|
Sound,
|
|
VideoCapture,
|
|
IEEE1394,
|
|
PCMCIA,
|
|
Camera,
|
|
TextIO,
|
|
Serial,
|
|
Parallel,
|
|
Peripheral,
|
|
Backlight,
|
|
Battery,
|
|
PowerSupply,
|
|
Dock,
|
|
ThermalSensor,
|
|
ThermalControl,
|
|
BlueTooth,
|
|
Bridge,
|
|
Platform,
|
|
Cryptography,
|
|
Event,
|
|
Input,
|
|
PNP,
|
|
OtherACPI,
|
|
OtherUSB,
|
|
OtherMultimedia,
|
|
OtherPeripheral,
|
|
OtherSensor,
|
|
OtherVirtual,
|
|
Other,
|
|
Last = Other
|
|
};
|
|
};
|
|
|
|
// Keep readDiskDeviceSubtypeFromString() in tdehardwaredevices.cpp in sync with this enum
|
|
namespace TDEDiskDeviceType {
|
|
enum TDEDiskDeviceType {
|
|
Null = 0x00000000,
|
|
MediaDevice = 0x00000001,
|
|
Floppy = 0x00000002,
|
|
CDROM = 0x00000004,
|
|
CDRW = 0x00000008,
|
|
DVDROM = 0x00000010,
|
|
DVDRAM = 0x00000020,
|
|
DVDRW = 0x00000040,
|
|
BDROM = 0x00000080,
|
|
BDRW = 0x00000100,
|
|
Zip = 0x00000200,
|
|
Jaz = 0x00000400,
|
|
Camera = 0x00000800,
|
|
LUKS = 0x00001000,
|
|
OtherCrypted = 0x00002000,
|
|
CDAudio = 0x00004000,
|
|
CDVideo = 0x00008000,
|
|
DVDVideo = 0x00010000,
|
|
BDVideo = 0x00020000,
|
|
Flash = 0x00040000,
|
|
USB = 0x00080000,
|
|
Tape = 0x00100000,
|
|
HDD = 0x00200000,
|
|
Optical = 0x00400000,
|
|
RAM = 0x00800000,
|
|
Loop = 0x01000000,
|
|
CompactFlash = 0x02000000,
|
|
MemoryStick = 0x04000000,
|
|
SmartMedia = 0x08000000,
|
|
SDMMC = 0x10000000,
|
|
UnlockedCrypt = 0x20000000,
|
|
Other = 0x80000000
|
|
};
|
|
|
|
inline TDEDiskDeviceType operator|(TDEDiskDeviceType a, TDEDiskDeviceType b)
|
|
{
|
|
return static_cast<TDEDiskDeviceType>(static_cast<int>(a) | static_cast<int>(b));
|
|
}
|
|
|
|
inline TDEDiskDeviceType operator&(TDEDiskDeviceType a, TDEDiskDeviceType b)
|
|
{
|
|
return static_cast<TDEDiskDeviceType>(static_cast<int>(a) & static_cast<int>(b));
|
|
}
|
|
|
|
inline TDEDiskDeviceType operator~(TDEDiskDeviceType a)
|
|
{
|
|
return static_cast<TDEDiskDeviceType>(~static_cast<int>(a));
|
|
}
|
|
};
|
|
|
|
namespace TDEDiskDeviceStatus {
|
|
enum TDEDiskDeviceStatus {
|
|
Null = 0x00000000,
|
|
Mountable = 0x00000001,
|
|
Removable = 0x00000002,
|
|
Inserted = 0x00000004,
|
|
Blank = 0x00000008,
|
|
UsedByDevice = 0x00000010,
|
|
UsesDevice = 0x00000020,
|
|
ContainsFilesystem = 0x00000040,
|
|
Hotpluggable = 0x00000080,
|
|
Other = 0x80000000
|
|
};
|
|
|
|
inline TDEDiskDeviceStatus operator|(TDEDiskDeviceStatus a, TDEDiskDeviceStatus b)
|
|
{
|
|
return static_cast<TDEDiskDeviceStatus>(static_cast<int>(a) | static_cast<int>(b));
|
|
}
|
|
|
|
inline TDEDiskDeviceStatus operator&(TDEDiskDeviceStatus a, TDEDiskDeviceStatus b)
|
|
{
|
|
return static_cast<TDEDiskDeviceStatus>(static_cast<int>(a) & static_cast<int>(b));
|
|
}
|
|
|
|
inline TDEDiskDeviceStatus operator~(TDEDiskDeviceStatus a)
|
|
{
|
|
return static_cast<TDEDiskDeviceStatus>(~static_cast<int>(a));
|
|
}
|
|
};
|
|
|
|
class TDECORE_EXPORT TDESensorCluster
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
TDESensorCluster();
|
|
|
|
TQString label;
|
|
double current;
|
|
double minimum;
|
|
double maximum;
|
|
double warning;
|
|
double critical;
|
|
};
|
|
|
|
class TDECORE_EXPORT TDEGenericDevice : public TQObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEGenericDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEGenericDevice();
|
|
|
|
/**
|
|
* @return a TDEGenericDeviceType::TDEGenericDeviceType specifying the device type
|
|
*/
|
|
TDEGenericDeviceType::TDEGenericDeviceType type();
|
|
|
|
/**
|
|
* @return a TQString with the device name, if any
|
|
*/
|
|
TQString name();
|
|
|
|
/**
|
|
* @return a TQString with the vendor name, if any
|
|
*/
|
|
TQString vendorName();
|
|
|
|
/**
|
|
* @return a TQString with the vendor model, if any
|
|
*/
|
|
TQString vendorModel();
|
|
|
|
/**
|
|
* @return a TQString with the serial number, if any
|
|
*/
|
|
TQString serialNumber();
|
|
|
|
/**
|
|
* @return a TQString with a friendly name
|
|
*
|
|
* While TDE tries very hard to generate and return a friendly name for this device,
|
|
* sometimes the best it will be able to do is "Unknown Device [xxxx:yyyy]"
|
|
*/
|
|
virtual TQString friendlyName();
|
|
|
|
/**
|
|
* @return a TQString with the device bus name, if any
|
|
*/
|
|
TQString deviceBus();
|
|
|
|
/**
|
|
* @return a TQString with the system path, if any
|
|
*
|
|
* This method is non-portable, so be careful!
|
|
*/
|
|
TQString systemPath();
|
|
|
|
/**
|
|
* @return a TQString with the system device node, if any
|
|
*
|
|
* This method is non-portable, so be careful!
|
|
*/
|
|
TQString deviceNode();
|
|
|
|
/**
|
|
* @return true if this device has been blacklisted for update actions
|
|
*/
|
|
bool blacklistedForUpdate();
|
|
|
|
/**
|
|
* @return a TQString containing a unique identifier for this device
|
|
*/
|
|
TQString uniqueID();
|
|
|
|
/**
|
|
* @return a TQString with the vendor ID, if any
|
|
*/
|
|
TQString vendorID();
|
|
|
|
/**
|
|
* @return a TQString with the model ID, if any
|
|
*/
|
|
TQString modelID();
|
|
|
|
/**
|
|
* @return a TQString with the encoded vendor, if any
|
|
*/
|
|
TQString vendorEncoded();
|
|
|
|
/**
|
|
* @return a TQString with the encoded model, if any
|
|
*/
|
|
TQString modelEncoded();
|
|
|
|
/**
|
|
* @return a TQString with the subvendor ID, if any
|
|
*/
|
|
TQString subVendorID();
|
|
|
|
/**
|
|
* @return a TQString with the submodel ID, if any
|
|
*/
|
|
TQString subModelID();
|
|
|
|
/**
|
|
* @return a TQString with the PCI device class, if any
|
|
*/
|
|
TQString PCIClass();
|
|
|
|
/**
|
|
* @return a TQString with the module alias string, if any
|
|
*/
|
|
TQString moduleAlias();
|
|
|
|
/**
|
|
* @return a TQString with the device driver, if any
|
|
*/
|
|
TQString deviceDriver();
|
|
|
|
/**
|
|
* @return a TQString with the subsystem type, if any
|
|
*/
|
|
TQString subsystem();
|
|
|
|
/**
|
|
* @return a TDEGenericDevice* with the parent device, if any
|
|
*/
|
|
TDEGenericDevice* parentDevice();
|
|
|
|
/**
|
|
* @return a TQString containing the friendly type name
|
|
*/
|
|
virtual TQString friendlyDeviceType();
|
|
|
|
/**
|
|
* @return a TQString containing the device bus ID, if any
|
|
*/
|
|
TQString busID();
|
|
|
|
/**
|
|
* Get an icon for this device
|
|
* @param size a TDEIcon::StdSizes structure specifying the desired icon size
|
|
* @return a TQPixmap containing the icon for the specified type
|
|
*/
|
|
virtual TQPixmap icon(TDEIcon::StdSizes size);
|
|
|
|
protected:
|
|
/**
|
|
* @param a TQString with the device name, if any
|
|
* @internal
|
|
*/
|
|
void internalSetName(TQString dn);
|
|
|
|
/**
|
|
* @param a TQString with the vendor name, if any
|
|
* @internal
|
|
*/
|
|
void internalSetVendorName(TQString vn);
|
|
|
|
/**
|
|
* @param a TQString with the vendor model, if any
|
|
* @internal
|
|
*/
|
|
void internalSetVendorModel(TQString vm);
|
|
|
|
/**
|
|
* @param a TQString with the serial number, if any
|
|
* @internal
|
|
*/
|
|
void internalSetSerialNumber(TQString sn);
|
|
|
|
/**
|
|
* @param a TQString with the device bus name, if any
|
|
* @internal
|
|
*/
|
|
void internalSetDeviceBus(TQString db);
|
|
|
|
/**
|
|
* @param a TQString with the system path, if any
|
|
* @internal
|
|
*
|
|
* This method is non-portable, so be careful!
|
|
*/
|
|
void internalSetSystemPath(TQString sp);
|
|
|
|
/**
|
|
* @param a TQString with the system device node, if any
|
|
* @internal
|
|
*
|
|
* This method is non-portable, so be careful!
|
|
*/
|
|
void internalSetDeviceNode(TQString sn);
|
|
|
|
/**
|
|
* @param bl true if this device has been blacklisted for update actions
|
|
* @internal
|
|
*/
|
|
void internalSetBlacklistedForUpdate(bool bl);
|
|
|
|
/**
|
|
* @param a TQString with the vendor ID, if any
|
|
* @internal
|
|
*/
|
|
void internalSetVendorID(TQString id);
|
|
|
|
/**
|
|
* @param a TQString with the model ID, if any
|
|
* @internal
|
|
*/
|
|
void internalSetModelID(TQString id);
|
|
|
|
/**
|
|
* @param a TQString with the encoded vendor, if any
|
|
* @internal
|
|
*/
|
|
void internalSetVendorEncoded(TQString id);
|
|
|
|
/**
|
|
* @param a TQString with the encoded model, if any
|
|
* @internal
|
|
*/
|
|
void internalSetModelEncoded(TQString id);
|
|
|
|
/**
|
|
* @param a TQString with the subvendor ID, if any
|
|
* @internal
|
|
*/
|
|
void internalSetSubVendorID(TQString id);
|
|
|
|
/**
|
|
* @param a TQString with the submodel ID, if any
|
|
* @internal
|
|
*/
|
|
void internalSetSubModelID(TQString id);
|
|
|
|
/**
|
|
* @param a TQString with the PCI device class, if any
|
|
* @internal
|
|
*/
|
|
void internalSetPCIClass(TQString cl);
|
|
|
|
/**
|
|
* @param a TQString with the module alias string, if any
|
|
* @internal
|
|
*/
|
|
void internalSetModuleAlias(TQString ma);
|
|
|
|
/**
|
|
* @param a TQString with the device driver, if any
|
|
* @internal
|
|
*/
|
|
void internalSetDeviceDriver(TQString dr);
|
|
|
|
/**
|
|
* @param a TQString with the subsystem type, if any
|
|
* @internal
|
|
*/
|
|
void internalSetSubsystem(TQString ss);
|
|
|
|
/**
|
|
* @param a TDEGenericDevice* with the parent device, if any
|
|
* @internal
|
|
*/
|
|
void internalSetParentDevice(TDEGenericDevice* pd);
|
|
|
|
private:
|
|
TDEGenericDeviceType::TDEGenericDeviceType m_deviceType;
|
|
TQString m_deviceName;
|
|
TQString m_systemPath;
|
|
TQString m_deviceNode;
|
|
TQString m_vendorName;
|
|
TQString m_vendorModel;
|
|
TQString m_serialNumber;
|
|
TQString m_deviceBus;
|
|
TQString m_uniqueID;
|
|
TQString m_vendorID;
|
|
TQString m_modelID;
|
|
TQString m_vendorenc;
|
|
TQString m_modelenc;
|
|
TQString m_subvendorID;
|
|
TQString m_submodelID;
|
|
TQString m_pciClass;
|
|
TQString m_modAlias;
|
|
TQString m_deviceDriver;
|
|
TQString m_subsystem;
|
|
TQString m_friendlyName;
|
|
bool m_blacklistedForUpdate;
|
|
TDEGenericDevice* m_parentDevice;
|
|
|
|
// Internal use only!
|
|
TQStringList m_externalSubtype;
|
|
TQString m_externalRulesFile;
|
|
TQString m_udevtype;
|
|
TQString m_udevdevicetypestring;
|
|
TQString udevdevicetypestring_alt;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
class TDECORE_EXPORT TDEStorageDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEStorageDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEStorageDevice();
|
|
|
|
/**
|
|
* @return a TQString with the disk or partition label, if any
|
|
*/
|
|
TQString diskLabel();
|
|
|
|
/**
|
|
* @return a TQString with the disk UUID, if any
|
|
*/
|
|
TQString diskUUID();
|
|
|
|
/**
|
|
* @return an OR-ed combination of TDEDiskDeviceType::TDEDiskDeviceType type flags
|
|
*/
|
|
TDEDiskDeviceType::TDEDiskDeviceType diskType();
|
|
|
|
/**
|
|
* @return an OR-ed combination of TDEDiskDeviceStatus::TDEDiskDeviceStatus type flags
|
|
*/
|
|
TDEDiskDeviceStatus::TDEDiskDeviceStatus diskStatus();
|
|
|
|
/**
|
|
* @return true if media inserted, false if no media available
|
|
*/
|
|
bool mediaInserted();
|
|
|
|
/**
|
|
* @return a TQString with the filesystem name, if any
|
|
*/
|
|
TQString fileSystemName();
|
|
|
|
/**
|
|
* @return a TQString with the filesystem usage string, if any
|
|
*/
|
|
TQString fileSystemUsage();
|
|
|
|
/**
|
|
* @return a TQStringList containing system paths to all devices with a lock on this device, if any
|
|
*/
|
|
TQStringList holdingDevices();
|
|
|
|
/**
|
|
* @return a TQStringList containing system paths to all devices locked by this device, if any
|
|
*/
|
|
TQStringList slaveDevices();
|
|
|
|
/**
|
|
* Mounts the device if not encrypted
|
|
*
|
|
* @param a TQString containing a requested mount name under /media, if desired
|
|
* @param a TQString containing any mount options for pmount, if desired
|
|
* @param a pointer to a TQString which will be populated with any error messages from pmount, if desired
|
|
* @param a pointer to an integer which will be populated with the return code from pmount, if desired
|
|
*
|
|
* @return a TQString with the mount path, if successful
|
|
*/
|
|
TQString mountDevice(TQString mediaName=TQString::null, TQString mountOptions=TQString::null, TQString* errRet=0, int* retcode=0);
|
|
|
|
/**
|
|
* Mounts the encrypted device if the correct passphrase is given
|
|
*
|
|
* @param a TQString containing the passphrase
|
|
* @param a TQString containing a requested mount name under /media, if desired
|
|
* @param a TQString containing any mount options for pmount, if desired
|
|
* @param a pointer to a TQString which will be populated with any error messages from pmount, if desired
|
|
* @param a pointer to an integer which will be populated with the return code from pmount, if desired
|
|
*
|
|
* @return a TQString with the mount path, if successful
|
|
*/
|
|
TQString mountEncryptedDevice(TQString passphrase, TQString mediaName=TQString::null, TQString mountOptions=TQString::null, TQString* errRet=0, int* retcode=0);
|
|
|
|
/**
|
|
* Unmounts the device
|
|
*
|
|
* @param a pointer to a TQString which will be populated with any error messages from pmount, if desired
|
|
* @param a pointer to an integer which will be populated with the return code from pmount, if desired
|
|
*
|
|
* @return TRUE if unmount was successful
|
|
*/
|
|
bool unmountDevice(TQString* errRet, int* retcode=0);
|
|
|
|
/**
|
|
* @return a TQString with the mount path, if mounted
|
|
*/
|
|
TQString mountPath();
|
|
|
|
/**
|
|
* @return an unsigned long with the device size in bytes
|
|
*/
|
|
unsigned long long deviceSize();
|
|
|
|
/**
|
|
* @return a TQString with the device size in human readable form
|
|
*/
|
|
TQString deviceFriendlySize();
|
|
|
|
/**
|
|
* Get an icon for this device
|
|
* @param size a TDEIcon::StdSizes structure specifying the desired icon size
|
|
* @return a TQPixmap containing the icon for the specified type
|
|
*
|
|
* This method overrides TDEGenericDevice::icon(TDEIcon::StdSizes size)
|
|
*/
|
|
TQPixmap icon(TDEIcon::StdSizes size);
|
|
|
|
/**
|
|
* @return a TQString with a friendly name
|
|
*
|
|
* This method overrides TDEGenericDevice::friendlyName()
|
|
*/
|
|
TQString friendlyName();
|
|
|
|
/**
|
|
* @return a TQString containing the friendly type name
|
|
*
|
|
* This method overrides TDEGenericDevice::friendlyDeviceType()
|
|
*/
|
|
TQString friendlyDeviceType();
|
|
|
|
/**
|
|
* @param an OR-ed combination of TDEDiskDeviceType::TDEDiskDeviceType type flags
|
|
*/
|
|
bool isDiskOfType(TDEDiskDeviceType::TDEDiskDeviceType tf);
|
|
|
|
/**
|
|
* @param an OR-ed combination of TDEDiskDeviceStatus::TDEDiskDeviceStatus type flags
|
|
*/
|
|
bool checkDiskStatus(TDEDiskDeviceStatus::TDEDiskDeviceStatus sf);
|
|
|
|
/**
|
|
* @param TRUE to engage media lock, FALSE to disable it
|
|
* @return TRUE on success, FALSE on failure
|
|
*
|
|
* This method currently works on CD-ROM drives and similar devices
|
|
*/
|
|
bool lockDriveMedia(bool lock);
|
|
|
|
/**
|
|
* @return TRUE on success, FALSE on failure
|
|
*
|
|
* This method currently works on CD-ROM drives and similar devices
|
|
*/
|
|
bool ejectDriveMedia();
|
|
|
|
/**
|
|
* @return TRUE on success, FALSE on failure
|
|
*
|
|
* This method currently works on all removable storage devices
|
|
*/
|
|
bool ejectDrive();
|
|
|
|
protected:
|
|
/**
|
|
* @param a TQString with the disk or partition label, if any
|
|
* @internal
|
|
*/
|
|
void internalSetDiskLabel(TQString dn);
|
|
|
|
/**
|
|
* @param a TQString with the disk UUID, if any
|
|
* @internal
|
|
*/
|
|
void internalSetDiskUUID(TQString id);
|
|
|
|
/**
|
|
* @param an OR-ed combination of TDEDiskDeviceType::TDEDiskDeviceType type flags
|
|
* @internal
|
|
*/
|
|
void internalSetDiskType(TDEDiskDeviceType::TDEDiskDeviceType tf);
|
|
|
|
/**
|
|
* @param an OR-ed combination of TDEDiskDeviceStatus::TDEDiskDeviceStatus type flags
|
|
* @internal
|
|
*/
|
|
void internalSetDiskStatus(TDEDiskDeviceStatus::TDEDiskDeviceStatus st);
|
|
|
|
/**
|
|
* @param a bool with the media status
|
|
* @internal
|
|
*/
|
|
void internalSetMediaInserted(bool inserted);
|
|
|
|
/**
|
|
* @param a TQString with the filesystem name, if any
|
|
* @internal
|
|
*/
|
|
void internalSetFileSystemName(TQString fn);
|
|
|
|
/**
|
|
* @param a TQString with the filesystem usage string, if any
|
|
* @internal
|
|
*/
|
|
void internalSetFileSystemUsage(TQString fu);
|
|
|
|
/**
|
|
* @param a TQStringList containing system paths to all devices with a lock on this device, if any
|
|
* @internal
|
|
*/
|
|
void internalSetHoldingDevices(TQStringList hd);
|
|
|
|
/**
|
|
* @param a TQStringList containing system paths to all devices locked by this device, if any
|
|
* @internal
|
|
*/
|
|
void internalSetSlaveDevices(TQStringList sd);
|
|
|
|
private:
|
|
TDEDiskDeviceType::TDEDiskDeviceType m_diskType;
|
|
TDEDiskDeviceStatus::TDEDiskDeviceStatus m_diskStatus;
|
|
TQString m_diskName;
|
|
TQString m_diskUUID;
|
|
TQString m_fileSystemName;
|
|
TQString m_fileSystemUsage;
|
|
bool m_mediaInserted;
|
|
TQString m_mountPath;
|
|
TQStringList m_holdingDevices;
|
|
TQStringList m_slaveDevices;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
class TDECORE_EXPORT TDECPUDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDECPUDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDECPUDevice();
|
|
|
|
/**
|
|
* @return a double with the current CPU frequency in MHz, if available
|
|
*/
|
|
double frequency();
|
|
|
|
/**
|
|
* @return a double with the minimum CPU frequency in MHz, if available
|
|
*/
|
|
double minFrequency();
|
|
|
|
/**
|
|
* @return a double with the maximum CPU frequency in MHz, if available
|
|
*/
|
|
double maxFrequency();
|
|
|
|
/**
|
|
* @return a double with the transition latency in ns, if available
|
|
*/
|
|
double transitionLatency();
|
|
|
|
/**
|
|
* @return a TQString with the current CPU governor policy, if available
|
|
*/
|
|
TQString governor();
|
|
|
|
/**
|
|
* @return a TQString with the current CPU scaling driver, if available
|
|
*/
|
|
TQString scalingDriver();
|
|
|
|
/**
|
|
* @return a TQStringList with the IDs of all processors that are dependent on the frequency/power settings of this one, if available
|
|
*/
|
|
TQStringList dependentProcessors();
|
|
|
|
/**
|
|
* @return a TQStringList with all valid scaling frequencies in Hz, if available
|
|
*/
|
|
TQStringList availableFrequencies();
|
|
|
|
/**
|
|
* @return a TQStringList with all available governor policies, if available
|
|
*/
|
|
TQStringList availableGovernors();
|
|
|
|
/**
|
|
* @return TRUE if permissions allow the CPU governor to be set, FALSE if not
|
|
*/
|
|
bool canSetGovernor();
|
|
|
|
/**
|
|
* @param gv a TQString with the new CPU governor policy name
|
|
*/
|
|
void setGovernor(TQString gv);
|
|
|
|
/**
|
|
* @return TRUE if permissions allow the CPU maximum frequency to be set, FALSE if not
|
|
*/
|
|
bool canSetMaximumScalingFrequency();
|
|
|
|
/**
|
|
* @param gv a double with the new CPU maximum frequency in MHz
|
|
*/
|
|
void setMaximumScalingFrequency(double fr);
|
|
|
|
/**
|
|
* @return an integer with the core number, starting at 0
|
|
*/
|
|
int coreNumber();
|
|
|
|
protected:
|
|
/**
|
|
* @param fr a double with the current CPU frequency in MHz, if available
|
|
* @internal
|
|
*/
|
|
void internalSetFrequency(double fr);
|
|
|
|
/**
|
|
* @param fr a double with the minimum CPU frequency in MHz, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMinFrequency(double fr);
|
|
|
|
/**
|
|
* @param fr a double with the maximum CPU frequency in MHz, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMaxFrequency(double fr);
|
|
|
|
/**
|
|
* @param tl a double with the transition latency in ns, if available
|
|
* @internal
|
|
*/
|
|
void internalSetTransitionLatency(double tl);
|
|
|
|
/**
|
|
* @param gr a TQString with the current CPU governor policy, if available
|
|
* @internal
|
|
*/
|
|
void internalSetGovernor(TQString gr);
|
|
|
|
/**
|
|
* @param dr a TQString with the current CPU scaling driver, if available
|
|
* @internal
|
|
*/
|
|
void internalSetScalingDriver(TQString dr);
|
|
|
|
/**
|
|
* @param dp a TQStringList with the IDs of all processors that are dependent on the frequency/power settings of this one, if available
|
|
* @internal
|
|
*/
|
|
void internalSetDependentProcessors(TQStringList dp);
|
|
|
|
/**
|
|
* @param af a TQStringList with all valid scaling frequencies in Hz, if available
|
|
* @internal
|
|
*/
|
|
void internalSetAvailableFrequencies(TQStringList af);
|
|
|
|
/**
|
|
* @param gp a TQStringList with all available governor policies, if available
|
|
* @internal
|
|
*/
|
|
void internalSetAvailableGovernors(TQStringList gp);
|
|
|
|
/**
|
|
* @param cn an integer with the core number, starting at 0
|
|
* @internal
|
|
*/
|
|
void internalSetCoreNumber(int cn);
|
|
|
|
private:
|
|
double m_frequency;
|
|
double m_minfrequency;
|
|
double m_maxfrequency;
|
|
double m_transitionlatency;
|
|
TQString m_governor;
|
|
TQString m_scalingdriver;
|
|
TQStringList m_tiedprocs;
|
|
TQStringList m_frequencies;
|
|
TQStringList m_governers;
|
|
int m_corenumber;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
namespace TDEBatteryStatus {
|
|
enum TDEBatteryStatus {
|
|
Charging,
|
|
Discharging,
|
|
Full,
|
|
Unknown = 0x80000000
|
|
};
|
|
};
|
|
|
|
class TDECORE_EXPORT TDEBatteryDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEBatteryDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEBatteryDevice();
|
|
|
|
/**
|
|
* @return a double with the current battery voltage, if available
|
|
*/
|
|
double voltage();
|
|
|
|
/**
|
|
* @return a double with the minimum battery voltage, if available
|
|
*/
|
|
double minimumVoltage();
|
|
|
|
/**
|
|
* @return a double with the maximum battery voltage, if available
|
|
*/
|
|
double maximumVoltage();
|
|
|
|
/**
|
|
* @return a double with the designed maximum battery voltage, if available
|
|
*/
|
|
double maximumDesignVoltage();
|
|
|
|
/**
|
|
* @return a double with the current battery energy in watt-hours, if available
|
|
*/
|
|
double energy();
|
|
|
|
/**
|
|
* @return a double with the current battery alarm energy in watt-hours, if available
|
|
*/
|
|
double alarmEnergy();
|
|
|
|
/**
|
|
* @return a double with the maximum battery energy in watt-hours, if available
|
|
*/
|
|
double maximumEnergy();
|
|
|
|
/**
|
|
* @return a double with the designed maximum battery energy in watt-hours, if available
|
|
*/
|
|
double maximumDesignEnergy();
|
|
|
|
/**
|
|
* @return a double with the current battery discharge rate in watt-hours, if available
|
|
*/
|
|
double dischargeRate();
|
|
|
|
/**
|
|
* @return a double with the current battery discharge time remaining in seconds, if available
|
|
*/
|
|
double timeRemaining();
|
|
|
|
/**
|
|
* @return a TQString with the battery technology, if available
|
|
*/
|
|
TQString technology();
|
|
|
|
/**
|
|
* @return a TDEBatteryStatus::TDEBatteryStatus with the current battery status
|
|
*/
|
|
TDEBatteryStatus::TDEBatteryStatus status();
|
|
|
|
/**
|
|
* @return TRUE if the battery is installed
|
|
*/
|
|
bool installed();
|
|
|
|
/**
|
|
* @return a double with the current battery charge in percent, if available
|
|
*/
|
|
double chargePercent();
|
|
|
|
protected:
|
|
/**
|
|
* @param a double with the current battery voltage, if available
|
|
* @internal
|
|
*/
|
|
void internalSetVoltage(double vt);
|
|
|
|
/**
|
|
* @param a double with the minimum battery voltage, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMinimumVoltage(double vt);
|
|
|
|
/**
|
|
* @param a double with the maximum battery voltage, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMaximumVoltage(double vt);
|
|
|
|
/**
|
|
* @param a double with the designed maximum battery voltage, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMaximumDesignVoltage(double vt);
|
|
|
|
/**
|
|
* @param a double with the current battery energy in watt-hours, if available
|
|
* @internal
|
|
*/
|
|
void internalSetEnergy(double vt);
|
|
|
|
/**
|
|
* @param a double with the current battery alarm energy in watt-hours, if available
|
|
* @internal
|
|
*/
|
|
void internalSetAlarmEnergy(double vt);
|
|
|
|
/**
|
|
* @param a double with the maximum battery energy in watt-hours, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMaximumEnergy(double vt);
|
|
|
|
/**
|
|
* @param a double with the designed maximum battery energy in watt-hours, if available
|
|
* @internal
|
|
*/
|
|
void internalSetMaximumDesignEnergy(double vt);
|
|
|
|
/**
|
|
* @param a double with the current battery discharge rate in volt-hours, if available
|
|
* @internal
|
|
*/
|
|
void internalSetDischargeRate(double vt);
|
|
|
|
/**
|
|
* @param a double with the current battery discharge time remaining in seconds, if available
|
|
* @internal
|
|
*/
|
|
void internalSetTimeRemaining(double tr);
|
|
|
|
/**
|
|
* @param a TQString with the battery technology, if available
|
|
* @internal
|
|
*/
|
|
void internalSetTechnology(TQString tc);
|
|
|
|
/**
|
|
* @param a TQString with the battery status, if available
|
|
* @internal
|
|
*/
|
|
void internalSetStatus(TQString tc);
|
|
|
|
/**
|
|
* @param TRUE if the battery is installed
|
|
* @internal
|
|
*/
|
|
void internalSetInstalled(bool tc);
|
|
|
|
private:
|
|
double m_currentVoltage;
|
|
double m_minimumVoltage;
|
|
double m_maximumVoltage;
|
|
double m_maximumDesignVoltage;
|
|
double m_alarmEnergy;
|
|
double m_currentEnergy;
|
|
double m_maximumEnergy;
|
|
double m_maximumDesignEnergy;
|
|
double m_dischargeRate;
|
|
double m_timeRemaining;
|
|
TQString m_technology;
|
|
TDEBatteryStatus::TDEBatteryStatus m_status;
|
|
bool m_installed;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
class TDECORE_EXPORT TDEMainsPowerDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEMainsPowerDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEMainsPowerDevice();
|
|
|
|
/**
|
|
* @return TRUE if power supply is online via mains power, FALSE if not
|
|
*/
|
|
bool online();
|
|
|
|
protected:
|
|
/**
|
|
* @param TRUE if power supply is online via mains power, FALSE if not
|
|
* @internal
|
|
*/
|
|
void internalSetOnline(bool vt);
|
|
|
|
private:
|
|
bool m_online;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
class TDECORE_EXPORT TDENetworkDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDENetworkDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDENetworkDevice();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's MAC address
|
|
*/
|
|
TQString macAddress();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's operational state
|
|
*/
|
|
TQString state();
|
|
|
|
/**
|
|
* @return TRUE if carrier is present, FALSE if not
|
|
*/
|
|
bool carrierPresent();
|
|
|
|
/**
|
|
* @return TRUE if device is dormant, FALSE if not
|
|
*/
|
|
bool dormant();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv4 address
|
|
*/
|
|
TQString ipV4Address();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv6 address
|
|
*/
|
|
TQString ipV6Address();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv4 netmask
|
|
*/
|
|
TQString ipV4Netmask();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv6 netmask
|
|
*/
|
|
TQString ipV6Netmask();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv4 broadcast
|
|
*/
|
|
TQString ipV4Broadcast();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv6 broadcast
|
|
*/
|
|
TQString ipV6Broadcast();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv4 destination
|
|
*/
|
|
TQString ipV4Destination();
|
|
|
|
/**
|
|
* @return a TQString containing the network device's IPv6 destination
|
|
*/
|
|
TQString ipV6Destination();
|
|
|
|
/**
|
|
* @return a double with the number of received bytes, if available
|
|
*/
|
|
double rxBytes();
|
|
|
|
/**
|
|
* @return a double with the number of transmitted bytes, if available
|
|
*/
|
|
double txBytes();
|
|
|
|
/**
|
|
* @return a double with the number of received packets, if available
|
|
*/
|
|
double rxPackets();
|
|
|
|
/**
|
|
* @return a double with the number of transmitted packets, if available
|
|
*/
|
|
double txPackets();
|
|
|
|
/**
|
|
* @return a pointer to a TDENetworkConnectionManager object, if available
|
|
*/
|
|
TDENetworkConnectionManager* connectionManager();
|
|
|
|
protected:
|
|
/**
|
|
* @param ma a TQString containing the network device's MAC address
|
|
* @internal
|
|
*/
|
|
void internalSetMacAddress(TQString ma);
|
|
|
|
/**
|
|
* @param st a TQString containing the network device's operational state
|
|
* @internal
|
|
*/
|
|
void internalSetState(TQString st);
|
|
|
|
/**
|
|
* @param TRUE if carrier is present, FALSE if not
|
|
* @internal
|
|
*/
|
|
void internalSetCarrierPresent(bool cp);
|
|
|
|
/**
|
|
* @param TRUE if device is dormant, FALSE if not
|
|
* @internal
|
|
*/
|
|
void internalSetDormant(bool dm);
|
|
|
|
/**
|
|
* @param ad a TQString containing the network device's IPv4 address
|
|
* @internal
|
|
*/
|
|
void internalSetIpV4Address(TQString ad);
|
|
|
|
/**
|
|
* @param ad a TQString containing the network device's IPv6 address
|
|
* @internal
|
|
*/
|
|
void internalSetIpV6Address(TQString ad);
|
|
|
|
/**
|
|
* @param nm a TQString containing the network device's IPv4 netmask
|
|
* @internal
|
|
*/
|
|
void internalSetIpV4Netmask(TQString nm);
|
|
|
|
/**
|
|
* @param nm a TQString containing the network device's IPv6 netmask
|
|
* @internal
|
|
*/
|
|
void internalSetIpV6Netmask(TQString nm);
|
|
|
|
/**
|
|
* @param br a TQString containing the network device's IPv4 broadcast
|
|
* @internal
|
|
*/
|
|
void internalSetIpV4Broadcast(TQString br);
|
|
|
|
/**
|
|
* @param br a TQString containing the network device's IPv6 broadcast
|
|
* @internal
|
|
*/
|
|
void internalSetIpV6Broadcast(TQString br);
|
|
|
|
/**
|
|
* @param ds a TQString containing the network device's IPv4 destination
|
|
* @internal
|
|
*/
|
|
void internalSetIpV4Destination(TQString ds);
|
|
|
|
/**
|
|
* @param ds a TQString containing the network device's IPv6 destination
|
|
* @internal
|
|
*/
|
|
void internalSetIpV6Destination(TQString ds);
|
|
|
|
/**
|
|
* @param rx a double with the number of received bytes, if available
|
|
* @internal
|
|
*/
|
|
void internalSetRxBytes(double rx);
|
|
|
|
/**
|
|
* @param tx a double with the number of transmitted bytes, if available
|
|
* @internal
|
|
*/
|
|
void internalSetTxBytes(double tx);
|
|
|
|
/**
|
|
* @param rx a double with the number of received packets, if available
|
|
* @internal
|
|
*/
|
|
void internalSetRxPackets(double rx);
|
|
|
|
/**
|
|
* @param tx a double with the number of transmitted packets, if available
|
|
* @internal
|
|
*/
|
|
void internalSetTxPackets(double tx);
|
|
|
|
/**
|
|
* @param mgr a pointer to a TDENetworkConnectionManager object, if available
|
|
*/
|
|
void internalSetConnectionManager(TDENetworkConnectionManager* mgr);
|
|
|
|
private:
|
|
TQString m_macAddress;
|
|
TQString m_state;
|
|
bool m_carrier;
|
|
bool m_dormant;
|
|
TQString m_ipV4Address;
|
|
TQString m_ipV6Address;
|
|
TQString m_ipV4Netmask;
|
|
TQString m_ipV6Netmask;
|
|
TQString m_ipV4Broadcast;
|
|
TQString m_ipV6Broadcast;
|
|
TQString m_ipV4Destination;
|
|
TQString m_ipV6Destination;
|
|
double m_rxbytes;
|
|
double m_txbytes;
|
|
double m_rxpackets;
|
|
double m_txpackets;
|
|
TDENetworkConnectionManager* m_connectionManager;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
namespace TDEDisplayPowerLevel {
|
|
enum TDEDisplayPowerLevel {
|
|
On,
|
|
Standby,
|
|
Suspend,
|
|
Off
|
|
};
|
|
};
|
|
|
|
class TDECORE_EXPORT TDEBacklightDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEBacklightDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEBacklightDevice();
|
|
|
|
/**
|
|
* @return a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level
|
|
*/
|
|
TDEDisplayPowerLevel::TDEDisplayPowerLevel powerLevel();
|
|
|
|
/**
|
|
* @return an integer with the number of discrete control steps available
|
|
*/
|
|
int brightnessSteps();
|
|
|
|
/**
|
|
* @return a double with the current brightness percentage
|
|
*/
|
|
double brightnessPercent();
|
|
|
|
/**
|
|
* @return TRUE if permissions allow brightness can be set, FALSE if not
|
|
*/
|
|
bool canSetBrightness();
|
|
|
|
/**
|
|
* @return an int with the current raw brightness
|
|
*/
|
|
int rawBrightness();
|
|
|
|
/**
|
|
* @param br an integer with the new raw brightness value
|
|
*/
|
|
void setRawBrightness(int br);
|
|
|
|
protected:
|
|
/**
|
|
* @param pl a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level
|
|
* @internal
|
|
*/
|
|
void internalSetPowerLevel(TDEDisplayPowerLevel::TDEDisplayPowerLevel pl);
|
|
|
|
/**
|
|
* @param br an integer with the maximum raw brightness value
|
|
* @internal
|
|
*/
|
|
void internalSetMaximumRawBrightness(int br);
|
|
|
|
/**
|
|
* @param br an integer with the current raw brightness value
|
|
* @internal
|
|
*/
|
|
void internalSetCurrentRawBrightness(int br);
|
|
|
|
private:
|
|
TDEDisplayPowerLevel::TDEDisplayPowerLevel m_powerLevel;
|
|
int m_currentBrightness;
|
|
int m_maximumBrightness;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
typedef TQPair<unsigned int, unsigned int> TDEResolutionPair;
|
|
typedef TQValueList< TDEResolutionPair > TDEResolutionList;
|
|
|
|
class TDECORE_EXPORT TDEMonitorDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEMonitorDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEMonitorDevice();
|
|
|
|
/**
|
|
* @return TRUE if a monitor is connected, FALSE if not
|
|
*/
|
|
bool connected();
|
|
|
|
/**
|
|
* @return TRUE if this port is enabled, FALSE if not
|
|
*/
|
|
bool enabled();
|
|
|
|
/**
|
|
* @return a TQByteArray containing this monitor's EDID information
|
|
*/
|
|
TQByteArray edid();
|
|
|
|
/**
|
|
* @return a TDEResolutionList containing this monitor's supported resolutions
|
|
*/
|
|
TDEResolutionList resolutions();
|
|
|
|
/**
|
|
* @return a TQString containing the display port type
|
|
*/
|
|
TQString portType();
|
|
|
|
/**
|
|
* @return a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level
|
|
*/
|
|
TDEDisplayPowerLevel::TDEDisplayPowerLevel powerLevel();
|
|
|
|
protected:
|
|
/**
|
|
* @param TRUE if a monitor is connected, FALSE if not
|
|
* @internal
|
|
*/
|
|
void internalSetConnected(bool cn);
|
|
|
|
/**
|
|
* @param TRUE if this port is enabled, FALSE if not
|
|
* @internal
|
|
*/
|
|
void internalSetEnabled(bool en);
|
|
|
|
/**
|
|
* @param ed a TQByteArray containing this monitor's EDID information
|
|
* @internal
|
|
*/
|
|
void internalSetEdid(TQByteArray ed);
|
|
|
|
/**
|
|
* @param rs a TDEResolutionList containing this monitor's supported resolutions
|
|
* @internal
|
|
*/
|
|
void internalSetResolutions(TDEResolutionList rs);
|
|
|
|
/**
|
|
* @param pt a TQString containing the display port type
|
|
* @internal
|
|
*/
|
|
void internalSetPortType(TQString pt);
|
|
|
|
/**
|
|
* @param pl a TDEDisplayPowerLevel::TDEDisplayPowerLevel with the current power level
|
|
* @internal
|
|
*/
|
|
void internalSetPowerLevel(TDEDisplayPowerLevel::TDEDisplayPowerLevel pl);
|
|
|
|
private:
|
|
bool m_connected;
|
|
bool m_enabled;
|
|
TQByteArray m_edid;
|
|
TDEResolutionList m_resolutions;
|
|
TQString m_portType;
|
|
TDEDisplayPowerLevel::TDEDisplayPowerLevel m_powerLevel;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
|
|
typedef TQMap<TQString, TDESensorCluster> TDESensorClusterMap;
|
|
|
|
class TDECORE_EXPORT TDESensorDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDESensorDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDESensorDevice();
|
|
|
|
/**
|
|
* @return a TDESensorClusterMap with the current sensor values
|
|
*/
|
|
TDESensorClusterMap values();
|
|
|
|
protected:
|
|
/**
|
|
* @param a TDESensorClusterMap with the current sensor values
|
|
* @internal
|
|
*/
|
|
void internalSetValues(TDESensorClusterMap cl);
|
|
|
|
private:
|
|
TDESensorClusterMap m_sensorValues;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
namespace TDESystemFormFactor {
|
|
enum TDESystemFormFactor {
|
|
Unclassified,
|
|
Desktop,
|
|
Laptop,
|
|
Server,
|
|
Other = 0x80000000
|
|
};
|
|
};
|
|
|
|
namespace TDESystemPowerState {
|
|
enum TDESystemPowerState {
|
|
Active,
|
|
Standby,
|
|
Suspend,
|
|
Hibernate,
|
|
PowerOff,
|
|
Reboot
|
|
};
|
|
};
|
|
|
|
namespace TDESystemHibernationMethod {
|
|
enum TDESystemHibernationMethod {
|
|
Unsupported,
|
|
Platform,
|
|
Shutdown,
|
|
Reboot,
|
|
TestProc,
|
|
Test
|
|
};
|
|
};
|
|
|
|
typedef TQValueList<TDESystemPowerState::TDESystemPowerState> TDESystemPowerStateList;
|
|
typedef TQValueList<TDESystemHibernationMethod::TDESystemHibernationMethod> TDESystemHibernationMethodList;
|
|
|
|
class TDECORE_EXPORT TDERootSystemDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDERootSystemDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDERootSystemDevice();
|
|
|
|
/**
|
|
* @return a TDESystemFormFactor::TDESystemFormFactor with the system's form factor
|
|
*/
|
|
TDESystemFormFactor::TDESystemFormFactor formFactor();
|
|
|
|
/**
|
|
* @return a TDESystemPowerStateList with all available power states
|
|
*/
|
|
TDESystemPowerStateList powerStates();
|
|
|
|
/**
|
|
* @return a TDESystemHibernationMethodList with all available hibernation methods
|
|
*/
|
|
TDESystemHibernationMethodList hibernationMethods();
|
|
|
|
/**
|
|
* @return a TDESystemHibernationMethod::TDESystemHibernationMethod with the current hibernation method
|
|
*/
|
|
TDESystemHibernationMethod::TDESystemHibernationMethod hibernationMethod();
|
|
|
|
/**
|
|
* @return an unsigned long with the number of bytes required to hibernate
|
|
*/
|
|
unsigned long diskSpaceNeededForHibernation();
|
|
|
|
/**
|
|
* @return TRUE if permissions allow the hibernation method to be set, FALSE if not
|
|
*/
|
|
bool canSetHibernationMethod();
|
|
|
|
/**
|
|
* @return TRUE if hardware and permissions allow the system to enter standby, FALSE if not
|
|
*/
|
|
bool canStandby();
|
|
|
|
/**
|
|
* @return TRUE if hardware and permissions allow the system to be suspended, FALSE if not
|
|
*/
|
|
bool canSuspend();
|
|
|
|
/**
|
|
* @return TRUE if hardware and permissions allow the system to be hibernated, FALSE if not
|
|
*/
|
|
bool canHibernate();
|
|
|
|
/**
|
|
* @return TRUE if permissions allow the system to be powered down, FALSE if not
|
|
*/
|
|
bool canPowerOff();
|
|
|
|
/**
|
|
* @return TRUE if permissions allow the system to be rebooted, FALSE if not
|
|
*/
|
|
bool canReboot();
|
|
|
|
/**
|
|
* @param hm a TDESystemHibernationMethod::TDESystemHibernationMethod with the desired hibernation method
|
|
*/
|
|
void setHibernationMethod(TDESystemHibernationMethod::TDESystemHibernationMethod hm);
|
|
|
|
/**
|
|
* @param ps a TDESystemPowerState::TDESystemPowerState with the desired power state
|
|
* @return TRUE if power state was set
|
|
*/
|
|
bool setPowerState(TDESystemPowerState::TDESystemPowerState ps);
|
|
|
|
protected:
|
|
/**
|
|
* @param ff a TDESystemFormFactor::TDESystemFormFactor with the system's form factor
|
|
* @internal
|
|
*/
|
|
void internalSetFormFactor(TDESystemFormFactor::TDESystemFormFactor ff);
|
|
|
|
/**
|
|
* @param ps a TDESystemPowerStateList with all available power states
|
|
* @internal
|
|
*/
|
|
void internalSetPowerStates(TDESystemPowerStateList ps);
|
|
|
|
/**
|
|
* @param hm a TDESystemHibernationMethodList with all available hibernation methods
|
|
* @internal
|
|
*/
|
|
void internalSetHibernationMethods(TDESystemHibernationMethodList hm);
|
|
|
|
/**
|
|
* @param hm a TDESystemHibernationMethod::TDESystemHibernationMethod with the current hibernation method
|
|
* @internal
|
|
*/
|
|
void internalSetHibernationMethod(TDESystemHibernationMethod::TDESystemHibernationMethod hm);
|
|
|
|
/**
|
|
* @param sz an unsigned long with the number of bytes required to hibernate
|
|
* @internal
|
|
*/
|
|
void internalSetDiskSpaceNeededForHibernation(unsigned long sz);
|
|
|
|
private:
|
|
TDESystemFormFactor::TDESystemFormFactor m_formFactor;
|
|
TDESystemPowerStateList m_powerStates;
|
|
TDESystemHibernationMethodList m_hibernationMethods;
|
|
TDESystemHibernationMethod::TDESystemHibernationMethod m_hibernationMethod;
|
|
unsigned long m_hibernationSpace;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
namespace TDEEventDeviceType {
|
|
enum TDEEventDeviceType {
|
|
Unknown,
|
|
ACPILidSwitch,
|
|
ACPISleepButton,
|
|
ACPIPowerButton,
|
|
Other = 0x80000000
|
|
};
|
|
};
|
|
|
|
// Keep friendlySwitchList() in tdehardwaredevices.cpp in sync with this enum
|
|
namespace TDESwitchType {
|
|
enum TDESwitchType {
|
|
Null = 0x00000000,
|
|
Lid = 0x00000001,
|
|
TabletMode = 0x00000002,
|
|
HeadphoneInsert = 0x00000004,
|
|
RFKill = 0x00000008,
|
|
Radio = 0x00000010,
|
|
MicrophoneInsert = 0x00000020,
|
|
Dock = 0x00000040,
|
|
LineOutInsert = 0x00000080,
|
|
JackPhysicalInsert = 0x00000100,
|
|
VideoOutInsert = 0x00000200,
|
|
CameraLensCover = 0x00000400,
|
|
KeypadSlide = 0x00000800,
|
|
FrontProximity = 0x00001000,
|
|
RotateLock = 0x00002000,
|
|
LineInInsert = 0x00004000
|
|
};
|
|
|
|
inline TDESwitchType operator|(TDESwitchType a, TDESwitchType b)
|
|
{
|
|
return static_cast<TDESwitchType>(static_cast<int>(a) | static_cast<int>(b));
|
|
}
|
|
|
|
inline TDESwitchType operator&(TDESwitchType a, TDESwitchType b)
|
|
{
|
|
return static_cast<TDESwitchType>(static_cast<int>(a) & static_cast<int>(b));
|
|
}
|
|
|
|
inline TDESwitchType operator~(TDESwitchType a)
|
|
{
|
|
return static_cast<TDESwitchType>(~static_cast<int>(a));
|
|
}
|
|
};
|
|
|
|
class TQSocketNotifier;
|
|
|
|
class TDECORE_EXPORT TDEEventDevice : public TDEGenericDevice
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEEventDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEEventDevice();
|
|
|
|
/**
|
|
* @return a TDEEventDeviceType::TDEEventDeviceType with the event device type, if known
|
|
*/
|
|
TDEEventDeviceType::TDEEventDeviceType eventType();
|
|
|
|
/**
|
|
* @return a TDESwitchType::TDESwitchType with all switches provided by this device
|
|
*/
|
|
TDESwitchType::TDESwitchType providedSwitches();
|
|
|
|
/**
|
|
* @return a TDESwitchType::TDESwitchType with all active switches provided by this device
|
|
*/
|
|
TDESwitchType::TDESwitchType activeSwitches();
|
|
|
|
/**
|
|
* @param switches a TDESwitchType::TDESwitchType with any switch flags set
|
|
* @return a TQStringList with friendly names for all set switch flags
|
|
*/
|
|
static TQStringList friendlySwitchList(TDESwitchType::TDESwitchType switches);
|
|
|
|
protected:
|
|
/**
|
|
* @param et a TDEEventDeviceType::TDEEventDeviceType with the event device type, if known
|
|
* @internal
|
|
*/
|
|
void internalSetEventType(TDEEventDeviceType::TDEEventDeviceType et);
|
|
|
|
/**
|
|
* @param sl a TDESwitchType::TDESwitchType with all switches provided by this device
|
|
* @internal
|
|
*/
|
|
void internalSetProvidedSwitches(TDESwitchType::TDESwitchType sl);
|
|
|
|
/**
|
|
* @param sl a TDESwitchType::TDESwitchType with all active switches provided by this device
|
|
* @internal
|
|
*/
|
|
void internalSetActiveSwitches(TDESwitchType::TDESwitchType sl);
|
|
|
|
/**
|
|
* @param hwmanager the master hardware manager
|
|
* @internal
|
|
*/
|
|
void internalStartFdMonitoring(TDEHardwareDevices* hwmanager);
|
|
|
|
protected slots:
|
|
void eventReceived();
|
|
|
|
signals:
|
|
/**
|
|
* @param keycode the code of the key that was pressed/released
|
|
* See include/linux/input.h for a complete list of keycodes
|
|
* @param device a TDEEventDevice* with the device that received the event
|
|
*/
|
|
void keyPressed(unsigned int keycode, TDEEventDevice* device);
|
|
|
|
private:
|
|
TDEEventDeviceType::TDEEventDeviceType m_eventType;
|
|
TDESwitchType::TDESwitchType m_providedSwitches;
|
|
TDESwitchType::TDESwitchType m_switchActive;
|
|
|
|
int m_fd;
|
|
bool m_fdMonitorActive;
|
|
TQSocketNotifier* m_eventNotifier;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
namespace TDEInputDeviceType {
|
|
enum TDEInputDeviceType {
|
|
Unknown,
|
|
ACPILidSwitch,
|
|
ACPISleepButton,
|
|
ACPIPowerButton,
|
|
Other = 0x80000000
|
|
};
|
|
};
|
|
|
|
class TDECORE_EXPORT TDEInputDevice : public TDEGenericDevice
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
* @param Device type
|
|
*/
|
|
TDEInputDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn=TQString::null);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEInputDevice();
|
|
|
|
/**
|
|
* @return a TDEInputDeviceType::TDEInputDeviceType with the input device type, if known
|
|
*/
|
|
TDEInputDeviceType::TDEInputDeviceType inputType();
|
|
|
|
protected:
|
|
/**
|
|
* @param it a TDEInputDeviceType::TDEInputDeviceType with the input device type, if known
|
|
* @internal
|
|
*/
|
|
void internalSetInputType(TDEInputDeviceType::TDEInputDeviceType it);
|
|
|
|
private:
|
|
TDEInputDeviceType::TDEInputDeviceType m_inputType;
|
|
|
|
friend class TDEHardwareDevices;
|
|
};
|
|
|
|
typedef TQPtrList<TDEGenericDevice> TDEGenericHardwareList;
|
|
typedef TQMap<TQString, TQString> TDEDeviceIDMap;
|
|
|
|
class KSimpleDirWatch;
|
|
|
|
class TDECORE_EXPORT TDEHardwareDevices : public TQObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
TDEHardwareDevices();
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TDEHardwareDevices();
|
|
|
|
/**
|
|
* Query all hardware capabilities on all devices
|
|
* This does not normally need to be called by an application, as
|
|
* device detection is handled internally and automatically
|
|
*
|
|
* A call to this method immediately invalidates any TDEGenericHardwareList
|
|
* structures returned by listAllPhysicalDevices()
|
|
*
|
|
* @return TRUE if successful
|
|
*/
|
|
bool queryHardwareInformation();
|
|
|
|
/**
|
|
* List all hardware capabilities on all devices
|
|
* @return TDEGenericHardwareList containing all known hardware devices
|
|
*/
|
|
TDEGenericHardwareList listAllPhysicalDevices();
|
|
|
|
/**
|
|
* List all hardware capabilities on all devices
|
|
* @param a TDEGenericDeviceType::TDEGenericDeviceType specifying the device class
|
|
* @return TDEGenericHardwareList containing all known hardware devices
|
|
*/
|
|
TDEGenericHardwareList listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl);
|
|
|
|
/**
|
|
* Return the device with system path @arg syspath, or 0 if no device exists for that path
|
|
* @return TDEGenericDevice
|
|
*/
|
|
TDEGenericDevice* findBySystemPath(TQString syspath);
|
|
|
|
/**
|
|
* Return the device with unique ID @arg uid, or 0 if no device exists for that uid
|
|
* @return TDEGenericDevice
|
|
*/
|
|
TDEGenericDevice* findByUniqueID(TQString uid);
|
|
|
|
/**
|
|
* Return the device with device node @arg devnode, or 0 if no device exists at that node
|
|
* @return TDEGenericDevice
|
|
*/
|
|
TDEGenericDevice* findByDeviceNode(TQString devnode);
|
|
|
|
/**
|
|
* Return the storage device with unique ID @arg uid, or 0 if no device exists for that uid
|
|
* @return TDEGenericDevice
|
|
*/
|
|
TDEStorageDevice* findDiskByUID(TQString uid);
|
|
|
|
/**
|
|
* Look up the device in the system PCI database
|
|
* @param vendorid a TQString containing the vendor ID in hexadecimal
|
|
* @param modelid a TQString containing the model ID in hexadecimal
|
|
* @param subvendorid a TQString containing the subvendor ID in hexadecimal
|
|
* @param submodelid a TQString containing the submodel ID in hexadecimal
|
|
* @return a TQString containing the device name, if found
|
|
*/
|
|
TQString findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);
|
|
|
|
/**
|
|
* Look up the device in the system USB database
|
|
* @param vendorid a TQString containing the vendor ID in hexadecimal
|
|
* @param modelid a TQString containing the model ID in hexadecimal
|
|
* @param subvendorid a TQString containing the subvendor ID in hexadecimal
|
|
* @param submodelid a TQString containing the submodel ID in hexadecimal
|
|
* @return a TQString containing the device name, if found
|
|
*/
|
|
TQString findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);
|
|
|
|
/**
|
|
* Look up the device in the system PNP database
|
|
* @param pnpid a TQString containing the PNP ID
|
|
* @return a TQString containing the device name, if found
|
|
*/
|
|
TQString findPNPDeviceName(TQString pnpid);
|
|
|
|
/**
|
|
* Look up the monitor manufacturer in the system display database
|
|
* @param pnpid a TQString containing the display manufacturer ID
|
|
* @return a TQString containing the manufacturer name, if found
|
|
*/
|
|
TQString findMonitorManufacturerName(TQString dpyid);
|
|
|
|
/**
|
|
* Get a friendly string describing a device type
|
|
* @param query a TDEGenericDeviceType::TDEGenericDeviceType specifying a device type
|
|
* @return a TQString containing the friendly type name
|
|
*/
|
|
TQString getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query);
|
|
|
|
/**
|
|
* Get an icon for a device type
|
|
* @param query a TDEGenericDeviceType::TDEGenericDeviceType specifying a device type
|
|
* @param size a TDEIcon::StdSizes structure specifying the desired icon size
|
|
* @return a TQPixmap containing the icon for the specified type
|
|
*/
|
|
TQPixmap getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, TDEIcon::StdSizes size);
|
|
|
|
/**
|
|
* Convenience function to obtain the root system device
|
|
* @return a pointer to a TDERootSystemDevice object
|
|
*/
|
|
TDERootSystemDevice* rootSystemDevice();
|
|
|
|
/**
|
|
* Rescan a hardware device to look for changes
|
|
* WARNING: This method can be very expensive. Use with caution!
|
|
* @param hwdevice TDEGenericDevice* with the device to rescan
|
|
*/
|
|
void rescanDeviceInformation(TDEGenericDevice* hwdevice);
|
|
|
|
/**
|
|
* Rescan a hardware device to look for changes
|
|
* WARNING: This method can be very expensive. Use with caution!
|
|
* The computational expense can be reduced somewhat if the device tree structure
|
|
* has not changed by calling this method with regenerateDeviceTree = FALSE.
|
|
* @param hwdevice TDEGenericDevice* with the device to rescan
|
|
* @param regenerateDeviceTree TRUE to update parent/child links in device tree
|
|
*/
|
|
void rescanDeviceInformation(TDEGenericDevice* hwdevice, bool regenerateDeviceTree);
|
|
|
|
/**
|
|
* Enable or disable automatic state updates of triggerless hardware devices
|
|
* such as CPUs and network cards. When enabled, your application will use
|
|
* additional CPU resources to continually poll triggerless hardware devices.
|
|
* Automatic updates are disabled by default.
|
|
* @param enable a bool specifiying whether or not automatic updates should be enabled
|
|
*/
|
|
void setTriggerlessHardwareUpdatesEnabled(bool enable);
|
|
|
|
/**
|
|
* Convert a byte count to human readable form
|
|
* @param bytes a double containing the number of bytes
|
|
* @return a TQString containing the human readable byte count
|
|
*/
|
|
static TQString bytesToFriendlySizeString(double bytes);
|
|
|
|
signals:
|
|
void hardwareAdded(TDEGenericDevice*);
|
|
void hardwareRemoved(TDEGenericDevice*);
|
|
void hardwareUpdated(TDEGenericDevice*);
|
|
void mountTableModified();
|
|
void hardwareEvent(TDEHardwareEvent::TDEHardwareEvent, TQString uuid);
|
|
|
|
/**
|
|
* @param keycode the code of the key that was pressed/released
|
|
* See include/linux/input.h for a complete list of keycodes
|
|
* @param device a TDEEventDevice* with the device that received the event
|
|
*/
|
|
void eventDeviceKeyPressed(unsigned int keycode, TDEEventDevice* device);
|
|
|
|
private slots:
|
|
void processHotPluggedHardware();
|
|
void processModifiedMounts();
|
|
void processModifiedCPUs();
|
|
void processStatelessDevices();
|
|
void processEventDeviceKeyPressed(unsigned int keycode, TDEEventDevice* edevice);
|
|
|
|
private:
|
|
void updateBlacklists(TDEGenericDevice* hwdevice, udev_device* dev);
|
|
|
|
private:
|
|
TDEGenericDevice *classifyUnknownDevice(udev_device* dev, TDEGenericDevice* existingdevice=0, bool force_full_classification=true);
|
|
TDEGenericDevice *classifyUnknownDeviceByExternalRules(udev_device* dev, TDEGenericDevice* existingdevice=0, bool classifySubDevices=false);
|
|
void updateExistingDeviceInformation(TDEGenericDevice* existingdevice, udev_device* dev=NULL);
|
|
|
|
void updateParentDeviceInformation();
|
|
void updateParentDeviceInformation(TDEGenericDevice* hwdevice);
|
|
|
|
void addCoreSystemDevices();
|
|
|
|
/**
|
|
* Get the binary monitor EDID for the specified sysfs path
|
|
* @return a TQByteArray containing the EDID
|
|
*/
|
|
TQByteArray getEDID(TQString path);
|
|
|
|
/**
|
|
* Get the monitor EDID name for the specified sysfs path
|
|
* @return a TQPair<TQString,TQString> containing the monitor vendor and model, if available
|
|
*/
|
|
TQPair<TQString,TQString> getEDIDMonitorName(TQString path);
|
|
|
|
struct udev *m_udevStruct;
|
|
struct udev_monitor *m_udevMonitorStruct;
|
|
TDEGenericHardwareList m_deviceList;
|
|
int m_procMountsFd;
|
|
KSimpleDirWatch* m_cpuWatch;
|
|
TQTimer* m_cpuWatchTimer;
|
|
TQTimer* m_deviceWatchTimer;
|
|
|
|
TQSocketNotifier* m_devScanNotifier;
|
|
TQSocketNotifier* m_mountScanNotifier;
|
|
|
|
TQStringList m_mountTable;
|
|
TQStringList m_cpuInfo;
|
|
|
|
TDEDeviceIDMap* pci_id_map;
|
|
TDEDeviceIDMap* usb_id_map;
|
|
TDEDeviceIDMap* pnp_id_map;
|
|
TDEDeviceIDMap* dpy_id_map;
|
|
|
|
friend class TDEGenericDevice;
|
|
friend class TDEStorageDevice;
|
|
friend class TDECPUDevice;
|
|
};
|
|
|
|
#endif // _TDEHARDWAREDEVICES_H
|