tdehardwaredevices.h

/* This file is part of the TDE libraries
   Copyright (C) 2012-2014 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 <tqptrlist.h>
#include <tqmap.h>
#include <tqdict.h>
#include <tqstring.h>
#include <tqstringlist.h>
 
#include "tdelibs_export.h"
#include "kicontheme.h"
 
#include "tdehwcommontypes.h"
 
// FIXME delete those headers after complete fixing everything in over modules
#include "tdegenericdevice.h"
#include "kiconloader.h"
extern "C" {
#include <libudev.h>
}
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include "tdestoragedevice.h"
#include "tdecpudevice.h"
#include "tdebatterydevice.h"
#include "tdemainspowerdevice.h"
#include "tdenetworkdevice.h"
#include "tdebacklightdevice.h"
#include "tdemonitordevice.h"
#include "tdesensordevice.h"
#include "tderootsystemdevice.h"
#include "tdeeventdevice.h"
#include "tdeinputdevice.h"
#include "tdecryptographiccarddevice.h"
 
struct udev_device;
 
class KSimpleDirWatch;
 
class TDEGenericDevice;
class TDEStorageDevice;
class TDENetworkDevice;
class TDEBacklightDevice;
class TDEMonitorDevice;
class TDESensorDevice;
class TDERootSystemDevice;
class TDEEventDevice;
class TDEInputDevice;
class TQSocketNotifier;
 
typedef TQPtrList<TDEGenericDevice> TDEGenericHardwareList;
typedef TQMap<TQString, TQString> TDEDeviceIDMap;
typedef TQDict<TDECPUDevice> TDECPUDeviceCache;
 
class TDECORE_EXPORT TDEHardwareDevices : public TQObject
{
    TQ_OBJECT
 
    public: 
        TDEHardwareDevices();
        
        ~TDEHardwareDevices();
 
        bool queryHardwareInformation();
 
        TDEGenericHardwareList listAllPhysicalDevices();
 
        TDEGenericHardwareList listByDeviceClass(TDEGenericDeviceType::TDEGenericDeviceType cl);
 
        TDEGenericDevice* findBySystemPath(TQString syspath);
 
        TDEGenericDevice* findByUniqueID(TQString uid);
 
        TDEGenericDevice* findByDeviceNode(TQString devnode);
 
        TDEStorageDevice* findDiskByUID(TQString uid);
 
        TDECPUDevice* findCPUBySystemPath(TQString syspath, bool inCache);
            
        TQString findPCIDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);
 
        TQString findUSBDeviceName(TQString vendorid, TQString modelid, TQString subvendorid, TQString submodelid);
 
        TQString findPNPDeviceName(TQString pnpid);
 
        TQString findMonitorManufacturerName(TQString dpyid);
 
        TQString getFriendlyDeviceTypeStringFromType(TDEGenericDeviceType::TDEGenericDeviceType query);
 
        TQPixmap getDeviceTypeIconFromType(TDEGenericDeviceType::TDEGenericDeviceType query, TDEIcon::StdSizes size);
 
        TDERootSystemDevice* rootSystemDevice();
 
        void rescanDeviceInformation(TDEGenericDevice* hwdevice, udev_device* dev = NULL, bool regenerateDeviceTree = true);
 
        void setTriggerlessHardwareUpdatesEnabled(bool enable);
 
        void setBatteryUpdatesEnabled(bool enable);
 
        static TQString bytesToFriendlySizeString(double bytes);
 
    signals:
        void hardwareAdded(TDEGenericDevice*);
        void hardwareRemoved(TDEGenericDevice*);
        void hardwareUpdated(TDEGenericDevice*);
 
        void eventDeviceKeyPressed(unsigned int keycode, TDEEventDevice* device);
 
    private slots:
        void processHotPluggedHardware();
        void processModifiedMounts();
        void processModifiedCPUs();
        void processBatteryDevices();
        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 *device, udev_device *dev=NULL);
 
        void updateParentDeviceInformation();
        void updateParentDeviceInformation(TDEGenericDevice* hwdevice);
 
        void addCoreSystemDevices();
 
        TQByteArray getEDID(TQString path);
        
        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_batteryWatchTimer;
        TQTimer* m_deviceWatchTimer;
 
        TQSocketNotifier* m_devScanNotifier;
        TQSocketNotifier* m_mountScanNotifier;
 
        TQMap<TQString, bool> m_mountTable;
        TQStringList m_cpuInfo;
 
        TDEDeviceIDMap* pci_id_map;
        TDEDeviceIDMap* usb_id_map;
        TDEDeviceIDMap* pnp_id_map;
        TDEDeviceIDMap* dpy_id_map;
        
        TDECPUDeviceCache m_cpuByPathCache;
 
    friend class TDEGenericDevice;
    friend class TDEStorageDevice;
    friend class TDECPUDevice;
};
 
#endif // _TDEHARDWAREDEVICES_H