Add network, battery, and AC power device classes and parsers to the TDE hardware library

2 files changed, 1105 insertions, 76 deletions

diff --git a/tdecore/tdehardwaredevices.cpp b/tdecore/tdehardwaredevices.cpp
index e62abeb37..7aa06feee 100644
--- a/tdecore/tdehardwaredevices.cpp
+++ b/tdecore/tdehardwaredevices.cpp
@@ -38,6 +38,16 @@
 #include <sys/ioctl.h>
 #include <linux/fs.h>
 
+// Network devices
+#include <sys/types.h>
+#include <ifaddrs.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+
 // BEGIN BLOCK
 // Copied from include/linux/genhd.h
 #define GENHD_FL_REMOVABLE                      1
@@ -103,6 +113,14 @@ void TDEGenericDevice::setVendorModel(TQString vm) {
 	m_vendorModel = vm;
 }
 
+TQString &TDEGenericDevice::serialNumber() {
+	return m_serialNumber;
+}
+
+void TDEGenericDevice::setSerialNumber(TQString sn) {
+	m_serialNumber = sn;
+}
+
 TQString &TDEGenericDevice::systemPath() {
 	return m_systemPath;
 }
@@ -278,6 +296,14 @@ TQString TDEGenericDevice::friendlyName() {
 	}
 
 	if (m_friendlyName.isNull()) {
+		// Could not identify based on model/vendor codes
+		// Try to construct something from the model/vendor strings if they are available
+		if (!m_vendorName.isNull() && !m_vendorModel.isNull()) {
+			m_friendlyName = m_vendorName + " " + m_vendorModel;
+		}
+	}
+
+	if (m_friendlyName.isNull()) {
 		// Could not identify based on model/vendor
 		// Guess by type
 		if (type() == TDEGenericDeviceType::CPU) {
@@ -484,6 +510,9 @@ TQString TDEStorageDevice::friendlyDeviceType() {
 	if (isDiskOfType(TDEDiskDeviceType::DVDRAM)) {
 		ret = i18n("DVDRAM Drive");
 	}
+	if (isDiskOfType(TDEDiskDeviceType::Optical)) {
+		ret = i18n("Optical Drive");
+	}
 	if (isDiskOfType(TDEDiskDeviceType::Zip)) {
 		ret = i18n("Zip Drive");
 	}
@@ -532,6 +561,9 @@ TQPixmap TDEStorageDevice::icon(KIcon::StdSizes size) {
 	if (isDiskOfType(TDEDiskDeviceType::DVDRAM)) {
 		ret = DesktopIcon("dvd_unmount", size);
 	}
+	if (isDiskOfType(TDEDiskDeviceType::Optical)) {
+		ret = DesktopIcon("cdrom_unmount", size);
+	}
 	if (isDiskOfType(TDEDiskDeviceType::Zip)) {
 		ret = DesktopIcon("zip_unmount", size);
 	}
@@ -588,37 +620,7 @@ unsigned long TDEStorageDevice::deviceSize() {
 }
 
 TQString TDEStorageDevice::deviceFriendlySize() {
-	double bytes = deviceSize();
-	TQString prettystring;
-
-	prettystring = TQString("%1b").arg(bytes);
-
-	if (bytes > 1024) {
-		bytes = bytes / 1024;
-		prettystring = TQString("%1Kb").arg(bytes, 0, 'f', 1);
-	}
-
-	if (bytes > 1024) {
-		bytes = bytes / 1024;
-		prettystring = TQString("%1Mb").arg(bytes, 0, 'f', 1);
-	}
-
-	if (bytes > 1024) {
-		bytes = bytes / 1024;
-		prettystring = TQString("%1Gb").arg(bytes, 0, 'f', 1);
-	}
-
-	if (bytes > 1024) {
-		bytes = bytes / 1024;
-		prettystring = TQString("%1Tb").arg(bytes, 0, 'f', 1);
-	}
-
-	if (bytes > 1024) {
-		bytes = bytes / 1024;
-		prettystring = TQString("%1Pb").arg(bytes, 0, 'f', 1);
-	}
-
-	return prettystring;
+	return TDEHardwareDevices::bytesToFriendlySizeString(deviceSize());
 }
 
 TQString TDEStorageDevice::mountPath() {
@@ -885,6 +887,264 @@ void TDESensorDevice::setValues(TDESensorClusterMap cl) {
 	m_sensorValues = cl;
 }
 
+TDEBatteryDevice::TDEBatteryDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) : TDEGenericDevice(dt, dn) {
+}
+
+TDEBatteryDevice::~TDEBatteryDevice() {
+}
+
+double TDEBatteryDevice::voltage() {
+	return m_currentVoltage;
+}
+
+void TDEBatteryDevice::setVoltage(double vt) {
+	m_currentVoltage = vt;
+}
+
+double TDEBatteryDevice::maximumVoltage() {
+	return m_maximumVoltage;
+}
+
+void TDEBatteryDevice::setMaximumVoltage(double vt) {
+	m_maximumVoltage = vt;
+}
+
+double TDEBatteryDevice::minimumVoltage() {
+	return m_minimumVoltage;
+}
+
+void TDEBatteryDevice::setMinimumVoltage(double vt) {
+	m_minimumVoltage = vt;
+}
+
+double TDEBatteryDevice::maximumDesignVoltage() {
+	return m_maximumDesignVoltage;
+}
+
+void TDEBatteryDevice::setMaximumDesignVoltage(double vt) {
+	m_maximumDesignVoltage = vt;
+}
+
+double TDEBatteryDevice::energy() {
+	return m_currentEnergy;
+}
+
+void TDEBatteryDevice::setEnergy(double vt) {
+	m_currentEnergy = vt;
+}
+
+double TDEBatteryDevice::alarmEnergy() {
+	return m_alarmEnergy;
+}
+
+void TDEBatteryDevice::setAlarmEnergy(double vt) {
+	m_alarmEnergy = vt;
+}
+
+double TDEBatteryDevice::maximumEnergy() {
+	return m_maximumEnergy;
+}
+
+void TDEBatteryDevice::setMaximumEnergy(double vt) {
+	m_maximumEnergy = vt;
+}
+
+double TDEBatteryDevice::maximumDesignEnergy() {
+	return m_maximumDesignEnergy;
+}
+
+void TDEBatteryDevice::setMaximumDesignEnergy(double vt) {
+	m_maximumDesignEnergy = vt;
+}
+
+double TDEBatteryDevice::dischargeRate() {
+	return m_dischargeRate;
+}
+
+void TDEBatteryDevice::setDischargeRate(double vt) {
+	m_dischargeRate = vt;
+}
+
+TQString &TDEBatteryDevice::technology() {
+	return m_technology;
+}
+
+void TDEBatteryDevice::setTechnology(TQString tc) {
+	m_technology = tc;
+}
+
+TQString &TDEBatteryDevice::status() {
+	return m_status;
+}
+
+void TDEBatteryDevice::setStatus(TQString tc) {
+	m_status = tc;
+}
+
+bool TDEBatteryDevice::installed() {
+	return m_installed;
+}
+
+void TDEBatteryDevice::setInstalled(bool tc) {
+	m_installed = tc;
+}
+
+double TDEBatteryDevice::chargePercent() {
+	return (m_currentEnergy/m_maximumEnergy)*100.0;
+}
+
+TDEMainsPowerDevice::TDEMainsPowerDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) : TDEGenericDevice(dt, dn) {
+}
+
+TDEMainsPowerDevice::~TDEMainsPowerDevice() {
+}
+
+bool TDEMainsPowerDevice::online() {
+	return m_online;
+}
+
+void TDEMainsPowerDevice::setOnline(bool tc) {
+	m_online = tc;
+}
+
+TDENetworkDevice::TDENetworkDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) : TDEGenericDevice(dt, dn) {
+	m_rxbytes = -1;
+	m_txbytes = -1;
+	m_rxpackets = -1;
+	m_txpackets = -1;
+}
+
+TDENetworkDevice::~TDENetworkDevice() {
+}
+
+TQString TDENetworkDevice::macAddress() {
+	return m_macAddress;
+}
+
+void TDENetworkDevice::setMacAddress(TQString ma) {
+	m_macAddress = ma;
+}
+
+TQString TDENetworkDevice::state() {
+	return m_state;
+}
+
+void TDENetworkDevice::setState(TQString st) {
+	m_state = st;
+}
+
+bool TDENetworkDevice::carrierPresent() {
+	return m_carrier;
+}
+
+void TDENetworkDevice::setCarrierPresent(bool cp) {
+	m_carrier = cp;
+}
+
+bool TDENetworkDevice::dormant() {
+	return m_dormant;
+}
+
+void TDENetworkDevice::setDormant(bool dm) {
+	m_dormant = dm;
+}
+
+TQString TDENetworkDevice::ipV4Address() {
+	return m_ipV4Address;
+}
+
+void TDENetworkDevice::setIpV4Address(TQString ad) {
+	m_ipV4Address = ad;
+}
+
+TQString TDENetworkDevice::ipV6Address() {
+	return m_ipV6Address;
+}
+
+void TDENetworkDevice::setIpV6Address(TQString ad) {
+	m_ipV6Address = ad;
+}
+
+TQString TDENetworkDevice::ipV4Netmask() {
+	return m_ipV4Netmask;
+}
+
+void TDENetworkDevice::setIpV4Netmask(TQString nm) {
+	m_ipV4Netmask = nm;
+}
+
+TQString TDENetworkDevice::ipV6Netmask() {
+	return m_ipV6Netmask;
+}
+
+void TDENetworkDevice::setIpV6Netmask(TQString nm) {
+	m_ipV6Netmask = nm;
+}
+
+TQString TDENetworkDevice::ipV4Broadcast() {
+	return m_ipV4Broadcast;
+}
+
+void TDENetworkDevice::setIpV4Broadcast(TQString br) {
+	m_ipV4Broadcast = br;
+}
+
+TQString TDENetworkDevice::ipV6Broadcast() {
+	return m_ipV6Broadcast;
+}
+
+void TDENetworkDevice::setIpV6Broadcast(TQString br) {
+	m_ipV6Broadcast = br;
+}
+
+TQString TDENetworkDevice::ipV4Destination() {
+	return m_ipV4Destination;
+}
+
+void TDENetworkDevice::setIpV4Destination(TQString ds) {
+	m_ipV4Destination = ds;
+}
+
+TQString TDENetworkDevice::ipV6Destination() {
+	return m_ipV6Destination;
+}
+
+void TDENetworkDevice::setIpV6Destination(TQString ds) {
+	m_ipV6Destination = ds;
+}
+
+double TDENetworkDevice::rxBytes() {
+	return m_rxbytes;
+}
+
+void TDENetworkDevice::setRxBytes(double rx) {
+	m_rxbytes = rx;
+}
+
+double TDENetworkDevice::txBytes() {
+	return m_txbytes;
+}
+
+void TDENetworkDevice::setTxBytes(double tx) {
+	m_txbytes = tx;
+}
+
+double TDENetworkDevice::rxPackets() {
+	return m_rxpackets;
+}
+
+void TDENetworkDevice::setRxPackets(double rx) {
+	m_rxpackets = rx;
+}
+
+double TDENetworkDevice::txPackets() {
+	return m_txpackets;
+}
+
+void TDENetworkDevice::setTxPackets(double tx) {
+	m_txpackets = tx;
+}
+
 TDEHardwareDevices::TDEHardwareDevices() {
 	// Initialize members
 	pci_id_map = 0;
@@ -955,12 +1215,21 @@ TDEHardwareDevices::TDEHardwareDevices() {
 		}
 #endif
 
+		// Some devices do not receive update signals from udev
+		// These devices must be polled, and a good polling interval is 1 second
+		m_deviceWatchTimer = new TQTimer(this);
+		connect( m_deviceWatchTimer, SIGNAL(timeout()), this, SLOT(processStatelessDevices()) );
+		m_deviceWatchTimer->start( 1000, FALSE ); // 1 second repeating timer
+
 		// Update internal device information
 		queryHardwareInformation();
 	}
 }
 
 TDEHardwareDevices::~TDEHardwareDevices() {
+	// Stop device scanning
+	m_deviceWatchTimer->stop();
+
 // [FIXME 0.01]
 #if 0
 	// Stop CPU scanning
@@ -1253,6 +1522,21 @@ void TDEHardwareDevices::processModifiedCPUs() {
 	}
 }
 
+void TDEHardwareDevices::processStatelessDevices() {
+	// Some devices do not emit changed signals
+	// So far, network cards and sensors need to be polled
+	TDEGenericDevice *hwdevice;
+
+	// We can't use m_deviceList directly as m_deviceList can only have one iterator active against it at any given time
+	TDEGenericHardwareList devList = listAllPhysicalDevices();
+	for ( hwdevice = devList.first(); hwdevice; hwdevice = devList.next() ) {
+		if ((hwdevice->type() == TDEGenericDeviceType::Network) || (hwdevice->type() == TDEGenericDeviceType::OtherSensor)) {
+			rescanDeviceInformation(hwdevice);
+			emit hardwareUpdated(hwdevice);
+		}
+	}
+}
+
 void TDEHardwareDevices::processModifiedMounts() {
 	// Detect what changed between the old mount table and the new one,
 	// and emit appropriate events
@@ -1400,6 +1684,9 @@ TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQ
 	}
 
 	if (disktypestring.upper() == "CD") {
+		disktype = disktype & ~TDEDiskDeviceType::HDD;
+		disktype = disktype | TDEDiskDeviceType::Optical;
+
 		if (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA")) == "1") {
 			disktype = disktype | TDEDiskDeviceType::CDROM;
 		}
@@ -1415,6 +1702,16 @@ TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQ
 			disktype = disktype | TDEDiskDeviceType::DVDRAM;
 			disktype = disktype & ~TDEDiskDeviceType::DVDROM;
 		}
+		if ((TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_R")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_R_DL")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_PLUS_R")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_MINUS_R")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_PLUS_R_DL")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_MINUS_R_DL")) == "1")
+			) {
+			disktype = disktype | TDEDiskDeviceType::DVDRW;
+			disktype = disktype & ~TDEDiskDeviceType::DVDROM;
+		}
 		if ((TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_RW")) == "1")
 			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_RW_DL")) == "1")
 			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_PLUS_RW")) == "1")
@@ -1422,13 +1719,23 @@ TDEDiskDeviceType::TDEDiskDeviceType classifyDiskType(udev_device* dev, const TQ
 			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_PLUS_RW_DL")) == "1")
 			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_MINUS_RW_DL")) == "1")
 			) {
-			disktype = disktype | TDEDiskDeviceType::DVDRW;
+			disktype = disktype | TDEDiskDeviceType::DVDRW;	// FIXME
 			disktype = disktype & ~TDEDiskDeviceType::DVDROM;
 		}
 		if (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD")) == "1") {
 			disktype = disktype | TDEDiskDeviceType::BDROM;
 			disktype = disktype & ~TDEDiskDeviceType::CDROM;
 		}
+		if ((TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_R")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_R_DL")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_PLUS_R")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_MINUS_R")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_PLUS_R_DL")) == "1")
+			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_DVD_MINUS_R_DL")) == "1")
+			) {
+			disktype = disktype | TDEDiskDeviceType::BDRW;	// FIXME
+			disktype = disktype & ~TDEDiskDeviceType::BDROM;
+		}
 		if ((TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_RW")) == "1")
 			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_RW_DL")) == "1")
 			|| (TQString(udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD_PLUS_RW")) == "1")
@@ -1519,6 +1826,9 @@ TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQStr
 	else if (query == "HID") {
 		ret = TDEGenericDeviceType::HID;
 	}
+	else if (query == "Monitor") {
+		ret = TDEGenericDeviceType::Monitor;
+	}
 	else if (query == "Network") {
 		ret = TDEGenericDeviceType::Network;
 	}
@@ -1537,6 +1847,9 @@ TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQStr
 	else if (query == "IEEE1394") {
 		ret = TDEGenericDeviceType::IEEE1394;
 	}
+	else if (query == "PCMCIA") {
+		ret = TDEGenericDeviceType::PCMCIA;
+	}
 	else if (query == "Camera") {
 		ret = TDEGenericDeviceType::Camera;
 	}
@@ -1556,7 +1869,7 @@ TDEGenericDeviceType::TDEGenericDeviceType readGenericDeviceTypeFromString(TQStr
 		ret = TDEGenericDeviceType::Battery;
 	}
 	else if (query == "Power") {
-		ret = TDEGenericDeviceType::Power;
+		ret = TDEGenericDeviceType::PowerSupply;
 	}
 	else if (query == "Dock") {
 		ret = TDEGenericDeviceType::Dock;
@@ -2016,28 +2329,10 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 			pnpgentype.remove(0, pnpgentype.findRev("/")+1);
 			pnpgentype.truncate(pnpgentype.find(":"));
 			if (pnpgentype.startsWith("PNP")) {
-				// We support a limited number of specific PNP IDs here
-				if (pnpgentype == "PNP0C0A") {
-					if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Battery);
-				}
-				else if (pnpgentype == "PNP0C0B") {
-					if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::ThermalControl);
-				}
-				else if (pnpgentype == "PNP0C0C") {
-					if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Power);
-				}
-				else if (pnpgentype == "PNP0C0D") {
-					if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Power);
-				}
-				else if (pnpgentype == "PNP0C0E") {
-					if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Power);
-				}
-				else if (pnpgentype == "PNP0C11") {
-					if (!device) device = new TDESensorDevice(TDEGenericDeviceType::ThermalSensor);
-				}
-				else {
-					if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
-				}
+				// If a device has been classified as belonging to the ACPI subsystem usually there is a "real" device related to it elsewhere in the system
+				// Furthermore, the "real" device elsewhere almost always has more functionality exposed via sysfs
+				// Therefore all ACPI subsystem devices should be stuffed in the OtherACPI category and largely ignored
+				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
 			}
 			else {
 				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
@@ -2114,8 +2409,11 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 			|| (devicesubsystem == "ata")) {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
 		}
+		if (devicesubsystem == "leds") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::OtherACPI);
+		}
 		if (devicesubsystem == "net") {
-			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Network);
+			if (!device) device = new TDENetworkDevice(TDEGenericDeviceType::Network);
 		}
 		if (devicesubsystem == "i2c") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::I2C);
@@ -2123,6 +2421,9 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 		if (devicesubsystem == "mdio_bus") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::MDIO);
 		}
+		if (devicesubsystem == "graphics") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::GPU);
+		}
 		if ((devicesubsystem == "event_source")
 			|| (devicesubsystem == "rtc")) {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Mainboard);
@@ -2133,12 +2434,18 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 		if (devicesubsystem == "firewire") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::IEEE1394);
 		}
+		if (devicesubsystem == "drm") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Monitor);
+		}
 		if (devicesubsystem == "serio") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Serial);
 		}
 		if (devicesubsystem == "ppdev") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Parallel);
 		}
+		if (devicesubsystem == "printer") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Printer);
+		}
 		if (devicesubsystem == "bridge") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Bridge);
 		}
@@ -2146,9 +2453,18 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 			|| (devicesubsystem == "pci_express")) {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Bus);
 		}
+		if (devicesubsystem == "pcmcia_socket") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::PCMCIA);
+		}
 		if (devicesubsystem == "platform") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
 		}
+		if (devicesubsystem == "ieee80211") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
+		}
+		if (devicesubsystem == "rfkill") {
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Platform);
+		}
 		if (devicesubsystem == "pnp") {
 			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::PNP);
 		}
@@ -2160,14 +2476,14 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 		if (devicesubsystem == "power_supply") {
 			TQString powersupplyname(udev_device_get_property_value(dev, "POWER_SUPPLY_NAME"));
 			if (powersupplyname.upper().startsWith("AC")) {
-				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Power);
+				if (!device) device = new TDEMainsPowerDevice(TDEGenericDeviceType::PowerSupply);
 			}
 			else {
-				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Battery);
+				if (!device) device = new TDEBatteryDevice(TDEGenericDeviceType::Battery);
 			}
 		}
 		if (devicesubsystem == "backlight") {
-			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Power);
+			if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::PowerSupply);
 		}
 
 		// Moderate accuracy classification, if PCI device class is available
@@ -2182,7 +2498,7 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::StorageController);
 			}
 			if (devicepciclass.startsWith("02")) {
-				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::Network);
+				if (!device) device = new TDENetworkDevice(TDEGenericDeviceType::Network);
 			}
 			if (devicepciclass.startsWith("03")) {
 				if (!device) device = new TDEGenericDevice(TDEGenericDeviceType::GPU);
@@ -2512,8 +2828,159 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 
 	if (device->type() == TDEGenericDeviceType::Network) {
 		// Network devices don't have devices nodes per se, but we can at least return the Linux network name...
-		devicenode = systempath;
-		devicenode.remove(0, devicenode.findRev("/")+1);
+		TQString potentialdevicenode = systempath;
+		potentialdevicenode.remove(0, potentialdevicenode.findRev("/")+1);
+		TQString potentialparentnode = systempath;
+		potentialparentnode.remove(0, potentialparentnode.findRev("/", potentialparentnode.findRev("/")-1)+1);
+		if (potentialparentnode.startsWith("net/")) {
+			devicenode = potentialdevicenode;
+		}
+
+		if (devicenode.isNull()) {
+			// Platform device, not a physical device
+			// HACK
+			// This only works because devices of type Platform only access the TDEGenericDevice class!
+			device->m_deviceType = TDEGenericDeviceType::Platform;
+		}
+		else {
+			// Gather network device information
+			TDENetworkDevice* ndevice = dynamic_cast<TDENetworkDevice*>(device);
+			TQString valuesnodename = systempath + "/";
+			TQDir valuesdir(valuesnodename);
+			valuesdir.setFilter(TQDir::All);
+			TQString nodename;
+			const TQFileInfoList *dirlist = valuesdir.entryInfoList();
+			if (dirlist) {
+				TQFileInfoListIterator valuesdirit(*dirlist);
+				TQFileInfo *dirfi;
+				while ( (dirfi = valuesdirit.current()) != 0 ) {
+					nodename = dirfi->fileName();
+					TQFile file( valuesnodename + nodename );
+					if ( file.open( IO_ReadOnly ) ) {
+						TQTextStream stream( &file );
+						TQString line;
+						line = stream.readLine();
+						if (nodename == "address") {
+							ndevice->setMacAddress(line);
+						}
+						if (nodename == "carrier") {
+							ndevice->setCarrierPresent(line.toInt());
+						}
+						if (nodename == "dormant") {
+							ndevice->setDormant(line.toInt());
+						}
+						if (nodename == "operstate") {
+							TQString friendlyState = line.lower();
+							friendlyState[0] = friendlyState[0].upper();
+							ndevice->setState(friendlyState);
+						}
+						file.close();
+					}
+					++valuesdirit;
+				}
+			}
+			// Gather connection information such as IP addresses
+			if (ndevice->state().upper() == "UP") {
+				struct ifaddrs *ifaddr, *ifa;
+				int family, s;
+				char host[NI_MAXHOST];
+
+				if (getifaddrs(&ifaddr) != -1) {
+					for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+						if (ifa->ifa_addr == NULL) {
+							continue;
+						}
+						
+						family = ifa->ifa_addr->sa_family;
+
+						if (TQString(ifa->ifa_name) == devicenode) {
+							if ((family == AF_INET) || (family == AF_INET6)) {
+								s = getnameinfo(ifa->ifa_addr, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+								if (s == 0) {
+									TQString address(host);
+									if (family == AF_INET) {
+										ndevice->setIpV4Address(address);
+									}
+									if (family == AF_INET6) {
+										address.truncate(address.findRev("%"));
+										ndevice->setIpV6Address(address);
+									}
+								}
+								s = getnameinfo(ifa->ifa_netmask, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+								if (s == 0) {
+									TQString address(host);
+									if (family == AF_INET) {
+										ndevice->setIpV4Netmask(address);
+									}
+									if (family == AF_INET6) {
+										address.truncate(address.findRev("%"));
+										ndevice->setIpV6Netmask(address);
+									}
+								}
+								s = getnameinfo(ifa->ifa_ifu.ifu_broadaddr, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+								if (s == 0) {
+									TQString address(host);
+									if (family == AF_INET) {
+										ndevice->setIpV4Broadcast(address);
+									}
+									if (family == AF_INET6) {
+										address.truncate(address.findRev("%"));
+										ndevice->setIpV6Broadcast(address);
+									}
+								}
+								s = getnameinfo(ifa->ifa_ifu.ifu_dstaddr, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+								if (s == 0) {
+									TQString address(host);
+									if (family == AF_INET) {
+										ndevice->setIpV4Destination(address);
+									}
+									if (family == AF_INET6) {
+										address.truncate(address.findRev("%"));
+										ndevice->setIpV6Destination(address);
+									}
+								}
+							}
+						}
+					}
+				}
+				
+				freeifaddrs(ifaddr);
+
+				// Gather statistics
+				TQString valuesnodename = systempath + "/statistics/";
+				TQDir valuesdir(valuesnodename);
+				valuesdir.setFilter(TQDir::All);
+				TQString nodename;
+				const TQFileInfoList *dirlist = valuesdir.entryInfoList();
+				if (dirlist) {
+					TQFileInfoListIterator valuesdirit(*dirlist);
+					TQFileInfo *dirfi;
+					while ( (dirfi = valuesdirit.current()) != 0 ) {
+						nodename = dirfi->fileName();
+						TQFile file( valuesnodename + nodename );
+						if ( file.open( IO_ReadOnly ) ) {
+							TQTextStream stream( &file );
+							TQString line;
+							line = stream.readLine();
+							if (nodename == "rx_bytes") {
+								ndevice->setRxBytes(line.toDouble());
+							}
+							if (nodename == "tx_bytes") {
+								ndevice->setTxBytes(line.toDouble());
+							}
+							if (nodename == "rx_packets") {
+								ndevice->setRxPackets(line.toDouble());
+							}
+							if (nodename == "tx_packets") {
+								ndevice->setTxPackets(line.toDouble());
+							}
+							file.close();
+						}
+						++valuesdirit;
+					}
+				}
+			}
+		}
 	}
 
 	if ((device->type() == TDEGenericDeviceType::OtherSensor) || (device->type() == TDEGenericDeviceType::ThermalSensor)) {
@@ -2538,23 +3005,27 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 						TQStringList sensornodelist = TQStringList::split("_", nodename);
 						TQString sensornodename = *(sensornodelist.at(0));
 						TQString sensornodetype = *(sensornodelist.at(1));
+						double lineValue = line.toDouble();
+						if (!sensornodename.contains("fan")) {
+							lineValue = lineValue / 1000.0;
+						}
 						if (sensornodetype == "label") {
 							sensors[sensornodename].label = line;
 						}
 						if (sensornodetype == "input") {
-							sensors[sensornodename].current = line.toDouble();
+							sensors[sensornodename].current = lineValue;
 						}
 						if (sensornodetype == "min") {
-							sensors[sensornodename].minimum = line.toDouble();
+							sensors[sensornodename].minimum = lineValue;
 						}
 						if (sensornodetype == "max") {
-							sensors[sensornodename].maximum = line.toDouble();
+							sensors[sensornodename].maximum = lineValue;
 						}
 						if (sensornodetype == "warn") {
-							sensors[sensornodename].warning = line.toDouble();
+							sensors[sensornodename].warning = lineValue;
 						}
 						if (sensornodetype == "crit") {
-							sensors[sensornodename].critical = line.toDouble();
+							sensors[sensornodename].critical = lineValue;
 						}
 						file.close();
 					}
@@ -2567,6 +3038,107 @@ TDEGenericDevice* TDEHardwareDevices::classifyUnknownDevice(udev_device* dev, TD
 		sdevice->setValues(sensors);
 	}
 
+	if (device->type() == TDEGenericDeviceType::Battery) {
+		// Populate all battery values
+		TDEBatteryDevice* bdevice = dynamic_cast<TDEBatteryDevice*>(device);
+		TQString valuesnodename = systempath + "/";
+		TQDir valuesdir(valuesnodename);
+		valuesdir.setFilter(TQDir::All);
+		TQString nodename;
+		const TQFileInfoList *dirlist = valuesdir.entryInfoList();
+		if (dirlist) {
+			TQFileInfoListIterator valuesdirit(*dirlist);
+			TQFileInfo *dirfi;
+			while ( (dirfi = valuesdirit.current()) != 0 ) {
+				nodename = dirfi->fileName();
+				TQFile file( valuesnodename + nodename );
+				if ( file.open( IO_ReadOnly ) ) {
+					TQTextStream stream( &file );
+					TQString line;
+					line = stream.readLine();
+					if (nodename == "alarm") {
+						bdevice->setAlarmEnergy(line.toDouble()/1000000.0);
+					}
+					if (nodename == "energy_full") {
+						bdevice->setMaximumEnergy(line.toDouble()/1000000.0);
+					}
+					if (nodename == "energy_full_design") {
+						bdevice->setMaximumDesignEnergy(line.toDouble()/1000000.0);
+					}
+					if (nodename == "energy_now") {
+						bdevice->setEnergy(line.toDouble()/1000000.0);
+					}
+					if (nodename == "manufacturer") {
+						bdevice->setVendorName(line.stripWhiteSpace());
+					}
+					if (nodename == "model_name") {
+						bdevice->setVendorModel(line.stripWhiteSpace());
+					}
+					if (nodename == "power_now") {
+						bdevice->setDischargeRate(line.toDouble()/1000000.0);
+					}
+					if (nodename == "present") {
+						bdevice->setInstalled(line.toInt());
+					}
+					if (nodename == "serial_number") {
+						bdevice->setSerialNumber(line.stripWhiteSpace());
+					}
+					if (nodename == "status") {
+						bdevice->setStatus(line);
+					}
+					if (nodename == "technology") {
+						bdevice->setTechnology(line);
+					}
+					if (nodename == "voltage_min_design") {
+						bdevice->setMinimumVoltage(line.toDouble()/1000000.0);
+					}
+					if (nodename == "voltage_now") {
+						bdevice->setVoltage(line.toDouble()/1000000.0);
+					}
+					file.close();
+				}
+				++valuesdirit;
+			}
+		}
+	}
+
+	if (device->type() == TDEGenericDeviceType::PowerSupply) {
+		// Populate all power supply values
+		TDEMainsPowerDevice* pdevice = dynamic_cast<TDEMainsPowerDevice*>(device);
+		TQString valuesnodename = systempath + "/";
+		TQDir valuesdir(valuesnodename);
+		valuesdir.setFilter(TQDir::All);
+		TQString nodename;
+		const TQFileInfoList *dirlist = valuesdir.entryInfoList();
+		if (dirlist) {
+			TQFileInfoListIterator valuesdirit(*dirlist);
+			TQFileInfo *dirfi;
+			while ( (dirfi = valuesdirit.current()) != 0 ) {
+				nodename = dirfi->fileName();
+				TQFile file( valuesnodename + nodename );
+				if ( file.open( IO_ReadOnly ) ) {
+					TQTextStream stream( &file );
+					TQString line;
+					line = stream.readLine();
+					if (nodename == "manufacturer") {
+						pdevice->setVendorName(line.stripWhiteSpace());
+					}
+					if (nodename == "model_name") {
+						pdevice->setVendorModel(line.stripWhiteSpace());
+					}
+					if (nodename == "online") {
+						pdevice->setOnline(line.toInt());
+					}
+					if (nodename == "serial_number") {
+						pdevice->setSerialNumber(line.stripWhiteSpace());
+					}
+					file.close();
+				}
+				++valuesdirit;
+			}
+		}
+	}
+
 	// Set basic device information again, as some information may have changed
 	device->setName(devicename);
 	device->setDeviceNode(devicenode);
@@ -3083,6 +3655,9 @@ TQString TDEHardwareDevices::getFriendlyDeviceTypeStringFromType(TDEGenericDevic
 	else if (query == TDEGenericDeviceType::HID) {
 		ret = i18n("HID");
 	}
+	else if (query == TDEGenericDeviceType::Monitor) {
+		ret = i18n("Monitor and Display");
+	}
 	else if (query == TDEGenericDeviceType::Network) {
 		ret = i18n("Network");
 	}
@@ -3101,6 +3676,9 @@ TQString TDEHardwareDevices::getFriendlyDeviceTypeStringFromType(TDEGenericDevic
 	else if (query == TDEGenericDeviceType::IEEE1394) {
 		ret = i18n("IEEE1394");
 	}
+	else if (query == TDEGenericDeviceType::PCMCIA) {
+		ret = i18n("PCMCIA");
+	}
 	else if (query == TDEGenericDeviceType::Camera) {
 		ret = i18n("Camera");
 	}
@@ -3119,8 +3697,8 @@ TQString TDEHardwareDevices::getFriendlyDeviceTypeStringFromType(TDEGenericDevic
 	else if (query == TDEGenericDeviceType::Battery) {
 		ret = i18n("Battery");
 	}
-	else if (query == TDEGenericDeviceType::Power) {
-		ret = i18n("Power Device");
+	else if (query == TDEGenericDeviceType::PowerSupply) {
+		ret = i18n("Power Supply");
 	}
 	else if (query == TDEGenericDeviceType::Dock) {
 		ret = i18n("Docking Station");
@@ -3217,6 +3795,9 @@ TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDE
 	else if (query == TDEGenericDeviceType::HID) {
 		ret = DesktopIcon("kcmdevices", size);	// FIXME
 	}
+	else if (query == TDEGenericDeviceType::Monitor) {
+		ret = DesktopIcon("background", size);
+	}
 	else if (query == TDEGenericDeviceType::Network) {
 		ret = DesktopIcon("kcmpci", size);
 	}
@@ -3235,6 +3816,9 @@ TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDE
 	else if (query == TDEGenericDeviceType::IEEE1394) {
 		ret = DesktopIcon("ieee1394", size);
 	}
+	else if (query == TDEGenericDeviceType::PCMCIA) {
+		ret = DesktopIcon("kcmdevices", size);	// FIXME
+	}
 	else if (query == TDEGenericDeviceType::Camera) {
 		ret = DesktopIcon("camera", size);
 	}
@@ -3253,7 +3837,7 @@ TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDE
 	else if (query == TDEGenericDeviceType::Battery) {
 		ret = DesktopIcon("energy", size);
 	}
-	else if (query == TDEGenericDeviceType::Power) {
+	else if (query == TDEGenericDeviceType::PowerSupply) {
 		ret = DesktopIcon("energy", size);
 	}
 	else if (query == TDEGenericDeviceType::Dock) {
@@ -3305,7 +3889,55 @@ TQPixmap TDEHardwareDevices::getDeviceTypeIconFromType(TDEGenericDeviceType::TDE
 	return ret;
 }
 
-TQPtrList<TDEGenericDevice> TDEHardwareDevices::listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl) {
+TQString TDEHardwareDevices::bytesToFriendlySizeString(double bytes) {
+	TQString prettystring;
+
+	prettystring = TQString("%1B").arg(bytes);
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1KB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1MB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1GB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1TB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1PB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1EB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1ZB").arg(bytes, 0, 'f', 1);
+	}
+
+	if (bytes > 1024) {
+		bytes = bytes / 1024;
+		prettystring = TQString("%1YB").arg(bytes, 0, 'f', 1);
+	}
+
+	return prettystring;
+}
+
+TDEGenericHardwareList TDEHardwareDevices::listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl) {
 	TDEGenericHardwareList ret;
 	ret.setAutoDelete(false);
 
diff --git a/tdecore/tdehardwaredevices.h b/tdecore/tdehardwaredevices.h
index 0073cb454..f25d80eda 100644
--- a/tdecore/tdehardwaredevices.h
+++ b/tdecore/tdehardwaredevices.h
@@ -56,19 +56,21 @@ enum TDEGenericDeviceType {
 	Mouse,
 	Keyboard,
 	HID,
+	Monitor,
 	Network,
 	Printer,
 	Scanner,
 	Sound,
 	VideoCapture,
 	IEEE1394,
+	PCMCIA,
 	Camera,
 	TextIO,
 	Serial,
 	Parallel,
 	Peripheral,
 	Battery,
-	Power,
+	PowerSupply,
 	Dock,
 	ThermalSensor,
 	ThermalControl,
@@ -237,6 +239,16 @@ class TDECORE_EXPORT TDEGenericDevice
 		void setVendorModel(TQString vm);
 
 		/**
+		* @return a TQString with the serial number, if any
+		*/
+		TQString &serialNumber();
+
+		/**
+		* @param a TQString with the serial number, if any
+		*/
+		void setSerialNumber(TQString sn);
+
+		/**
 		* @return a TQString with a friendly name
 		*
 		* While TDE tries very hard to generate and return a friendly name for this device,
@@ -431,6 +443,7 @@ class TDECORE_EXPORT TDEGenericDevice
 		TQString m_deviceNode;
 		TQString m_vendorName;
 		TQString m_vendorModel;
+		TQString m_serialNumber;
 		TQString m_deviceBus;
 		TQString m_uniqueID;
 		TQString m_vendorID;
@@ -759,6 +772,381 @@ class TDECORE_EXPORT TDECPUDevice : public TDEGenericDevice
 		TQStringList m_frequencies;
 };
 
+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();
+
+		/**
+		* @param a double with the current battery voltage, if available
+		*/
+		void setVoltage(double vt);
+
+		/**
+		* @return a double with the minimum battery voltage, if available
+		*/
+		double minimumVoltage();
+
+		/**
+		* @param a double with the minimum battery voltage, if available
+		*/
+		void setMinimumVoltage(double vt);
+
+		/**
+		* @return a double with the maximum battery voltage, if available
+		*/
+		double maximumVoltage();
+
+		/**
+		* @param a double with the maximum battery voltage, if available
+		*/
+		void setMaximumVoltage(double vt);
+
+		/**
+		* @return a double with the designed maximum battery voltage, if available
+		*/
+		double maximumDesignVoltage();
+
+		/**
+		* @param a double with the designed maximum battery voltage, if available
+		*/
+		void setMaximumDesignVoltage(double vt);
+
+		/**
+		* @return a double with the current battery energy in watt-hours, if available
+		*/
+		double energy();
+
+		/**
+		* @param a double with the current battery energy in watt-hours, if available
+		*/
+		void setEnergy(double vt);
+
+		/**
+		* @return a double with the current battery alarm energy in watt-hours, if available
+		*/
+		double alarmEnergy();
+
+		/**
+		* @param a double with the current battery alarm energy in watt-hours, if available
+		*/
+		void setAlarmEnergy(double vt);
+
+		/**
+		* @return a double with the maximum battery energy in watt-hours, if available
+		*/
+		double maximumEnergy();
+
+		/**
+		* @param a double with the maximum battery energy in watt-hours, if available
+		*/
+		void setMaximumEnergy(double vt);
+
+		/**
+		* @return a double with the designed maximum battery energy in watt-hours, if available
+		*/
+		double maximumDesignEnergy();
+
+		/**
+		* @param a double with the designed maximum battery energy in watt-hours, if available
+		*/
+		void setMaximumDesignEnergy(double vt);
+
+		/**
+		* @return a double with the current battery discharge rate in volt-hours, if available
+		*/
+		double dischargeRate();
+
+		/**
+		* @param a double with the current battery discharge rate in volt-hours, if available
+		*/
+		void setDischargeRate(double vt);
+
+		/**
+		* @return a TQString with the battery technology, if available
+		*/
+		TQString &technology();
+
+		/**
+		* @param a TQString with the battery technology, if available
+		*/
+		void setTechnology(TQString tc);
+
+		/**
+		* @return a TQString with the battery status, if available
+		*/
+		TQString &status();
+
+		/**
+		* @param a TQString with the battery status, if available
+		*/
+		void setStatus(TQString tc);
+
+		/**
+		* @return TRUE if the battery is installed
+		*/
+		bool installed();
+
+		/**
+		* @param TRUE if the battery is installed
+		*/
+		void setInstalled(bool tc);
+
+		/**
+		* @return a double with the current battery charge in percent, if available
+		*/
+		double chargePercent();
+
+	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;
+		TQString m_technology;
+		TQString m_status;
+		bool m_installed;
+};
+
+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();
+
+		/**
+		* @param TRUE if power supply is online via mains power, FALSE if not
+		*/
+		void setOnline(bool vt);
+
+	private:
+		bool m_online;
+};
+
+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();
+
+		/**
+		* @param ma a TQString containing the network device's MAC address
+		*/
+		void setMacAddress(TQString ma);
+
+		/**
+		* @return a TQString containing the network device's operational state
+		*/
+		TQString state();
+
+		/**
+		* @param st a TQString containing the network device's operational state
+		*/
+		void setState(TQString st);
+
+		/**
+		* @return TRUE if carrier is present, FALSE if not
+		*/
+		bool carrierPresent();
+
+		/**
+		* @param TRUE if carrier is present, FALSE if not
+		*/
+		void setCarrierPresent(bool cp);
+
+		/**
+		* @return TRUE if device is dormant, FALSE if not
+		*/
+		bool dormant();
+
+		/**
+		* @param TRUE if device is dormant, FALSE if not
+		*/
+		void setDormant(bool dm);
+
+		/**
+		* @return a TQString containing the network device's IPv4 address
+		*/
+		TQString ipV4Address();
+
+		/**
+		* @param ad a TQString containing the network device's IPv4 address
+		*/
+		void setIpV4Address(TQString ad);
+
+		/**
+		* @return a TQString containing the network device's IPv6 address
+		*/
+		TQString ipV6Address();
+
+		/**
+		* @param ad a TQString containing the network device's IPv6 address
+		*/
+		void setIpV6Address(TQString ad);
+
+		/**
+		* @return a TQString containing the network device's IPv4 netmask
+		*/
+		TQString ipV4Netmask();
+
+		/**
+		* @param nm a TQString containing the network device's IPv4 netmask
+		*/
+		void setIpV4Netmask(TQString nm);
+
+		/**
+		* @return a TQString containing the network device's IPv6 netmask
+		*/
+		TQString ipV6Netmask();
+
+		/**
+		* @param nm a TQString containing the network device's IPv6 netmask
+		*/
+		void setIpV6Netmask(TQString nm);
+
+		/**
+		* @return a TQString containing the network device's IPv4 broadcast
+		*/
+		TQString ipV4Broadcast();
+
+		/**
+		* @param br a TQString containing the network device's IPv4 broadcast
+		*/
+		void setIpV4Broadcast(TQString br);
+
+		/**
+		* @return a TQString containing the network device's IPv6 broadcast
+		*/
+		TQString ipV6Broadcast();
+
+		/**
+		* @param br a TQString containing the network device's IPv6 broadcast
+		*/
+		void setIpV6Broadcast(TQString br);
+
+		/**
+		* @return a TQString containing the network device's IPv4 destination
+		*/
+		TQString ipV4Destination();
+
+		/**
+		* @param ds a TQString containing the network device's IPv4 destination
+		*/
+		void setIpV4Destination(TQString ds);
+
+		/**
+		* @return a TQString containing the network device's IPv6 destination
+		*/
+		TQString ipV6Destination();
+
+		/**
+		* @param ds a TQString containing the network device's IPv6 destination
+		*/
+		void setIpV6Destination(TQString ds);
+
+		/**
+		* @return a double with the number of received bytes, if available
+		*/
+		double rxBytes();
+
+		/**
+		* @param rx a double with the number of received bytes, if available
+		*/
+		void setRxBytes(double rx);
+
+		/**
+		* @return a double with the number of transmitted bytes, if available
+		*/
+		double txBytes();
+
+		/**
+		* @param tx a double with the number of transmitted bytes, if available
+		*/
+		void setTxBytes(double tx);
+
+		/**
+		* @return a double with the number of received packets, if available
+		*/
+		double rxPackets();
+
+		/**
+		* @param rx a double with the number of received packets, if available
+		*/
+		void setRxPackets(double rx);
+
+		/**
+		* @return a double with the number of transmitted packets, if available
+		*/
+		double txPackets();
+
+		/**
+		* @param tx a double with the number of transmitted packets, if available
+		*/
+		void setTxPackets(double tx);
+
+	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;
+};
+
 typedef TQMap<TQString, TDESensorCluster> TDESensorClusterMap;
 
 class TDECORE_EXPORT TDESensorDevice : public TDEGenericDevice
@@ -824,16 +1212,16 @@ class TDECORE_EXPORT TDEHardwareDevices : public TQObject
 
 		/**
 		*  List all hardware capabilities on all devices
-		*  @return TQPtrList<TDEGenericDevice> containing all known hardware devices
+		*  @return TDEGenericHardwareList containing all known hardware devices
 		*/
-		TQPtrList<TDEGenericDevice> listAllPhysicalDevices();
+		TDEGenericHardwareList listAllPhysicalDevices();
 
 		/**
 		*  List all hardware capabilities on all devices
 		*  @param a TDEGenericDeviceType::TDEGenericDeviceType specifying the device class
-		*  @return TQPtrList<TDEGenericDevice> containing all known hardware devices
+		*  @return TDEGenericHardwareList containing all known hardware devices
 		*/
-		TQPtrList<TDEGenericDevice> listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl);
+		TDEGenericHardwareList listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl);
 
 		/**
 		*  Return the device with system path @arg syspath, or 0 if no device exists for that path
@@ -895,6 +1283,13 @@ class TDECORE_EXPORT TDEHardwareDevices : public TQObject
 		*/
 		TQPixmap getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, KIcon::StdSizes size);
 
+		/**
+		*  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*);
@@ -905,6 +1300,7 @@ class TDECORE_EXPORT TDEHardwareDevices : public TQObject
 		void processHotPluggedHardware();
 		void processModifiedMounts();
 		void processModifiedCPUs();
+		void processStatelessDevices();
 
 	private:
 		void rescanDeviceInformation(TDEGenericDevice* hwdevice);
@@ -925,6 +1321,7 @@ class TDECORE_EXPORT TDEHardwareDevices : public TQObject
 		int m_procMountsFd;
 		KSimpleDirWatch* m_cpuWatch;
 		TQTimer* m_cpuWatchTimer;
+		TQTimer* m_deviceWatchTimer;
 
 		TQSocketNotifier* m_devScanNotifier;
 		TQSocketNotifier* m_mountScanNotifier;