1 /*
2     Copyright 2012 Patrick von Reth <vonreth@kde.org>
3     Copyright 2005-2007 Kevin Ottens <ervin@kde.org>
4 
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Lesser General Public
7     License as published by the Free Software Foundation; either
8     version 2.1 of the License, or (at your option) version 3, or any
9     later version accepted by the membership of KDE e.V. (or its
10     successor approved by the membership of KDE e.V.), which shall
11     act as a proxy defined in Section 6 of version 3 of the license.
12 
13     This library is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16     Lesser General Public License for more details.
17 
18     You should have received a copy of the GNU Lesser General Public
19     License along with this library. If not, see <http://www.gnu.org/licenses/>.
20 */
21 
22 #include "wmidevice.h"
23 
24 #include <solid-lite/genericinterface.h>
25 
26 #include "wmiquery.h"
27 #include "wmimanager.h"
28 #include "wmideviceinterface.h"
29 #include "wmigenericinterface.h"
30 //#include "wmiprocessor.h"
31 #include "wmiblock.h"
32 #include "wmistorageaccess.h"
33 #include "wmistorage.h"
34 #include "wmicdrom.h"
35 #include "wmivolume.h"
36 #include "wmiopticaldisc.h"
37 //#include "wmicamera.h"
38 #include "wmiportablemediaplayer.h"
39 //#include "wminetworkinterface.h"
40 //#include "wmiacadapter.h"
41 //#include "wmibattery.h"
42 //#include "wmibutton.h"
43 //#include "wmiaudiointerface.h"
44 //#include "wmidvbinterface.h"
45 //#include "wmivideo.h"
46 
47 #include <QDebug>
48 
49 using namespace Solid::Backends::Wmi;
50 
51 class Solid::Backends::Wmi::WmiDevicePrivate
52 {
53 public:
WmiDevicePrivate(const QString & _udi)54     WmiDevicePrivate(const QString &_udi)
55         : parent(0)
56         , m_udi(_udi)
57         , m_wmiTable()
58         , m_wmiProperty()
59         , m_wmiValue()
60     {
61     }
62 
~WmiDevicePrivate()63     ~WmiDevicePrivate()
64     {
65     }
66 
discoverType()67     void discoverType()
68     {
69         if (!convertUDItoWMI(m_udi,m_wmiTable,m_wmiProperty,m_wmiValue,m_type))
70             return;
71         interfaceList<<getInterfaces(m_type);
72 
73     }
74 
udi() const75     const QString udi() const { return m_udi; }
76 
sendQuery()77     WmiQuery::Item sendQuery()
78     {
79         if(m_item.isNull()){
80             QString query("SELECT * FROM " + m_wmiTable + " WHERE " + m_wmiProperty + "='" + m_wmiValue + "'");
81             WmiQuery::ItemList items = WmiQuery::instance().sendQuery(query);
82             Q_ASSERT(items.length() == 1);
83             if(items.length() != 1)
84                 qDebug()<<"WmiDevicePrivate::sendQuery() failed";
85             m_item = items[0];
86         }
87         return m_item;
88     }
89 
convertUDItoWMI(const QString & udi,QString & wmiTable,QString & wmiProperty,QString & wmiValue,Solid::DeviceInterface::Type & type)90     static bool convertUDItoWMI(const QString &udi, QString &wmiTable, QString &wmiProperty, QString &wmiValue,Solid::DeviceInterface::Type &type)
91     {
92         QString _udi = udi;
93         QStringList x = _udi.remove("/org/kde/solid/wmi/").split('/');
94         if (x.size() != 2 || x[1].isEmpty()) {
95             qDebug() << "invalid udi detected" << udi;
96             return false;
97         }
98         type = DeviceInterface::fromString(x[0]);
99         wmiProperty = getPropertyNameForUDI(type);
100         wmiValue = x[1];
101         wmiTable = getWMITable(type);
102 //        qDebug()<<"wmi"<<  type <<wmiTable <<wmiProperty <<wmiValue;
103         return true;
104     }
105 
exists(const QString & udi)106     static bool exists(const QString &udi)
107     {
108         QString wmiTable;
109         QString wmiProperty;
110         QString wmiValue;
111         Solid::DeviceInterface::Type solidDevice;
112 
113         if (!convertUDItoWMI(udi, wmiTable, wmiProperty, wmiValue,solidDevice))
114             return false;
115 
116 
117         QString query("SELECT * FROM " + wmiTable + " WHERE " + wmiProperty + "='" + wmiValue + "'");
118 		WmiQuery::ItemList list = WmiQuery::instance().sendQuery(query);
119         if(list.size() > 0)
120             return true;
121         qWarning()<<"Device UDI:"<<udi<<"doesnt exist";
122 //        qDebug()<<query;
123         return false;
124     }
125 
generateUDI(const QString & key,const QString & property)126     static QString generateUDI(const QString &key, const QString &property)
127     {
128         return QString("/org/kde/solid/wmi/%1/%2").arg(key).arg(property);
129     }
130 
getInterfaces(const Solid::DeviceInterface::Type & type)131     static QList<Solid::DeviceInterface::Type> getInterfaces(const Solid::DeviceInterface::Type &type)
132     {
133         QList<Solid::DeviceInterface::Type> interfaceList;
134         interfaceList<<type;
135 
136         switch (type)
137         {
138         case Solid::DeviceInterface::GenericInterface:
139             break;
140         //case Solid::DeviceInterface::Processor:
141         //    break;
142         //case Solid::DeviceInterface::Block:
143             break;
144         case Solid::DeviceInterface::StorageAccess:
145             break;
146         case Solid::DeviceInterface::StorageDrive:
147             break;
148         case Solid::DeviceInterface::OpticalDrive:
149             interfaceList <<Solid::DeviceInterface::Block<<Solid::DeviceInterface::StorageDrive;
150             break;
151         case Solid::DeviceInterface::StorageVolume:
152             interfaceList <<Solid::DeviceInterface::Block<<Solid::DeviceInterface::StorageAccess;
153             break;
154         case Solid::DeviceInterface::OpticalDisc:
155             interfaceList <<Solid::DeviceInterface::Block<<Solid::DeviceInterface::StorageVolume;
156             break;
157         //case Solid::DeviceInterface::Camera:
158         //    break;
159         case Solid::DeviceInterface::PortableMediaPlayer:
160             break;
161         /*case Solid::DeviceInterface::NetworkInterface:
162             break;
163         case Solid::DeviceInterface::AcAdapter:
164             break;
165         case Solid::DeviceInterface::Battery:
166             break;
167         case Solid::DeviceInterface::Button:
168             break;
169         case Solid::DeviceInterface::AudioInterface:
170             break;
171         case Solid::DeviceInterface::DvbInterface:
172             break;
173         case Solid::DeviceInterface::Video:
174             break;
175         */
176         case Solid::DeviceInterface::Unknown:
177         case Solid::DeviceInterface::Last:
178         default:
179             break;
180         }
181         if (interfaceList.size() == 0)
182             qWarning() << "no interface found for type" << type;
183         return interfaceList;
184     }
185 
getUDIKey(const Solid::DeviceInterface::Type & type)186     static QString getUDIKey(const Solid::DeviceInterface::Type &type)
187     {
188         QStringList list = DeviceInterface::toStringList(type);
189         QString value = list.size() > 0 ? list[0] : QString();
190         return value;
191     }
192 
getWMITable(const Solid::DeviceInterface::Type & type)193     static QString getWMITable(const Solid::DeviceInterface::Type &type)
194     {
195         QString wmiTable;
196         switch (type)
197         {
198         case Solid::DeviceInterface::GenericInterface:
199             break;
200         //case Solid::DeviceInterface::Processor:
201         //    wmiTable = "Win32_Processor";
202         //    break;
203         case Solid::DeviceInterface::Block:
204             break;
205         case Solid::DeviceInterface::StorageAccess:
206             wmiTable = "Win32_DiskPartition";
207             break;
208         case Solid::DeviceInterface::StorageDrive:
209             wmiTable = "Win32_DiskDrive";
210             break;
211         case Solid::DeviceInterface::OpticalDrive:
212             wmiTable = "Win32_CDROMDrive";
213             break;
214         case Solid::DeviceInterface::StorageVolume:
215             wmiTable = "Win32_DiskPartition";
216             break;
217         case Solid::DeviceInterface::OpticalDisc:
218             wmiTable = "Win32_CDROMDrive";
219             break;
220         //case Solid::DeviceInterface::Camera:
221         //    break;
222         case Solid::DeviceInterface::PortableMediaPlayer:
223             break;
224         /*case Solid::DeviceInterface::NetworkInterface:
225             break;
226         case Solid::DeviceInterface::AcAdapter:
227         case Solid::DeviceInterface::Battery:
228             wmiTable = "Win32_Battery";
229             break;
230         case Solid::DeviceInterface::Button:
231             break;
232         case Solid::DeviceInterface::AudioInterface:
233             break;
234         case Solid::DeviceInterface::DvbInterface:
235             break;
236         case Solid::DeviceInterface::Video:
237             break;
238         */
239         case Solid::DeviceInterface::Unknown:
240         case Solid::DeviceInterface::Last:
241         default:
242             wmiTable = "unknown";
243             break;
244         }
245         return wmiTable;
246     }
247 
getIgnorePattern(const Solid::DeviceInterface::Type & type)248     static QString getIgnorePattern(const Solid::DeviceInterface::Type &type)
249     {
250         QString propertyName;
251         switch(type){
252         case Solid::DeviceInterface::OpticalDisc:
253             propertyName = " WHERE MediaLoaded=TRUE";
254             break;
255         }
256         return propertyName;
257     }
258 
getPropertyNameForUDI(const Solid::DeviceInterface::Type & type)259     static QString getPropertyNameForUDI(const Solid::DeviceInterface::Type &type)
260     {
261         QString propertyName;
262         switch(type){
263         case Solid::DeviceInterface::OpticalDrive:
264         case Solid::DeviceInterface::OpticalDisc:
265             propertyName = "Drive";
266             break;
267         case Solid::DeviceInterface::StorageDrive:
268             propertyName = "Index";
269             break;
270         default:
271             propertyName = "DeviceID";
272         }
273 
274         return propertyName;
275     }
276 
generateUDIList(const Solid::DeviceInterface::Type & type)277     static QStringList generateUDIList(const Solid::DeviceInterface::Type &type)
278     {
279         QStringList result;
280 
281         WmiQuery::ItemList list = WmiQuery::instance().sendQuery( "SELECT * FROM " + getWMITable(type) + getIgnorePattern(type));
282         foreach(const WmiQuery::Item& item, list) {
283             QString propertyName = getPropertyNameForUDI(type);
284             QString property = item.getProperty(propertyName).toString();
285             result << generateUDI(getUDIKey(type),property.toLower());
286         }
287         return result;
288     }
289 
290     WmiDevice *parent;
291     static int m_instanceCount;
292     QString m_parent_uid;
293     QString m_udi;
294     QString m_wmiTable;
295     QString m_wmiProperty;
296     QString m_wmiValue;
297     Solid::DeviceInterface::Type m_type;
298     WmiQuery::Item m_item;
299     QList<Solid::DeviceInterface::Type> interfaceList;
300 
301 };
302 
303 Q_DECLARE_METATYPE(ChangeDescription)
Q_DECLARE_METATYPE(QList<ChangeDescription>)304 Q_DECLARE_METATYPE(QList<ChangeDescription>)
305 WmiDevice::WmiDevice(const QString &udi)
306     : Device(), d(new WmiDevicePrivate(udi))
307 {
308     d->discoverType();
309     foreach (Solid::DeviceInterface::Type type, d->interfaceList)
310     {
311         createDeviceInterface(type);
312     }
313 }
314 
~WmiDevice()315 WmiDevice::~WmiDevice()
316 {
317     //delete d->parent;
318     delete d;
319 }
320 
generateUDIList(const Solid::DeviceInterface::Type & type)321 QStringList WmiDevice::generateUDIList(const Solid::DeviceInterface::Type &type)
322 {
323     return WmiDevicePrivate::generateUDIList(type);
324 }
325 
326 
exists(const QString & udi)327 bool WmiDevice::exists(const QString &udi)
328 {
329     return WmiDevicePrivate::exists(udi);
330 }
331 
isValid() const332 bool WmiDevice::isValid() const
333 {
334     // does not work
335     //return sendQuery( "SELECT * FROM Win32_SystemDevices WHERE PartComponent='\\\\\\\\BEAST\root\cimv2:Win32_Processor.DeviceID=\"CPU0\"'" ).count() == 1;
336     return true;
337 }
338 
udi() const339 QString WmiDevice::udi() const
340 {
341     return d->udi();
342 }
343 
parentUdi() const344 QString WmiDevice::parentUdi() const
345 {
346     if(!d->m_parent_uid.isEmpty())
347         return d->m_parent_uid;
348     QString result;
349     const QString value = udi().split("/").last();
350 
351     switch(d->m_type){
352     case Solid::DeviceInterface::StorageVolume:
353     case Solid::DeviceInterface::StorageAccess:
354             result = "/org/kde/solid/wmi/storage/"+property("DiskIndex").toString();
355             break;
356     case Solid::DeviceInterface::OpticalDisc:
357         result = "/org/kde/solid/wmi/storage.cdrom/"+property("Drive").toString().toLower();
358         break;
359     }
360 
361     if(result.isEmpty() && !value.isEmpty()){
362         result = udi();
363         result = result.remove("/"+value);
364     }
365     d->m_parent_uid = result;
366     return d->m_parent_uid;
367 }
368 
vendor() const369 QString WmiDevice::vendor() const
370 {
371     QString propertyName;
372     switch(type()){
373     //case Solid::DeviceInterface::Processor:
374     //    propertyName = "Manufacturer";
375     //    break;
376     case Solid::DeviceInterface::OpticalDrive:
377     case Solid::DeviceInterface::OpticalDisc:
378         propertyName = "Caption";
379         break;
380     //case Solid::DeviceInterface::Battery:
381     //    propertyName = "DeviceID";
382     //    break;
383     case Solid::DeviceInterface::StorageAccess:
384     case Solid::DeviceInterface::StorageVolume:
385     {
386         WmiDevice parent(parentUdi());
387         return parent.vendor();
388     }
389         break;
390     case Solid::DeviceInterface::StorageDrive:
391         propertyName = "Model";
392         break;
393     default:
394         propertyName = "DeviceID";//TODO:
395     }
396     return property(propertyName).toString();
397 }
398 
product() const399 QString WmiDevice::product() const
400 {
401     QString propertyName;
402     switch(type()){
403     //case Solid::DeviceInterface::Processor:
404     //    propertyName = "Name";
405     //    break;
406     case Solid::DeviceInterface::StorageAccess:
407     case Solid::DeviceInterface::StorageVolume:
408     {
409         WmiQuery::Item item = win32LogicalDiskByDiskPartitionID(property("DeviceID").toString());
410         return item.getProperty("VolumeName").toString();
411     }
412         break;
413     //case Solid::DeviceInterface::AcAdapter:
414     //    return description();
415     default:
416         propertyName = "Caption";
417     }
418     return property(propertyName).toString();
419 }
420 
icon() const421 QString WmiDevice::icon() const
422 {
423     QString propertyName;
424     switch(type()){
425     //case Solid::DeviceInterface::Processor:
426     //    propertyName = "cpu";
427     //    break;
428     case Solid::DeviceInterface::OpticalDisc:
429     {
430         WmiDevice dev(udi());
431         OpticalDisc disk(&dev);
432         if(disk.availableContent() | Solid::OpticalDisc::Audio)//no other are recognized yet
433             propertyName = "media-optical-audio";
434         else
435             propertyName = "drive-optical";
436 
437         break;
438     }
439     //case Solid::DeviceInterface::Battery:
440     //    propertyName = "battery";
441     //    break;
442     case Solid::DeviceInterface::StorageAccess:
443     case Solid::DeviceInterface::StorageVolume:
444     {
445         WmiDevice parent(parentUdi());
446         Storage storage(&parent);
447         if(storage.bus() == Solid::StorageDrive::Usb)
448             propertyName = "drive-removable-media-usb-pendrive";
449         else
450             propertyName = "drive-harddisk";
451     }
452         break;
453     }
454     return propertyName;
455 }
456 
emblems() const457 QStringList WmiDevice::emblems() const
458 {
459     return QStringList(); // TODO
460 }
461 
description() const462 QString WmiDevice::description() const
463 {
464     switch(type()){
465         case Solid::DeviceInterface::OpticalDisc:
466             return property("VolumeName").toString();
467         /*case Solid::DeviceInterface::AcAdapter:
468         return QObject::tr("A/C Adapter");
469         case Solid::DeviceInterface::Battery:
470         {
471             WmiDevice dev(udi());
472             Battery bat(&dev);
473             return QObject::tr("%1 Battery", "%1 is battery technology").arg(bat.batteryTechnology());
474         }
475         */
476         default:
477             return product();
478     }
479 }
480 
481 
property(const QString & key) const482 QVariant WmiDevice::property(const QString &key) const
483 {
484     WmiQuery::Item item = d->sendQuery();
485 
486     QVariant result = item.getProperty(key);
487 //    qDebug()<<"property"<<key<<result;
488     return result;
489 }
490 
type() const491 const Solid::DeviceInterface::Type WmiDevice::type() const{
492     return d->m_type;
493 }
494 
495 /**
496  * @brief WmiDevice::win32DiskPartitionByDeviceIndex
497  * @param deviceID something like "\\.\PHYSICALDRIVE0"
498  * @return
499  */
win32DiskPartitionByDeviceIndex(const QString & deviceID)500 WmiQuery::Item WmiDevice::win32DiskPartitionByDeviceIndex(const QString &deviceID){
501     WmiQuery::Item result;
502     QString id = deviceID;
503     QString query("ASSOCIATORS OF {Win32_DiskDrive.DeviceID='"+ id +"'} WHERE AssocClass = Win32_DiskDriveToDiskPartition");
504     WmiQuery::ItemList items = WmiQuery::instance().sendQuery(query);
505     if(items.length()>0){
506         result = items[0];
507     }
508     return result;
509 }
510 
511 /**
512  * @brief WmiDevice::win32DiskDriveByDiskPartitionID
513  * @param deviceID something like "disk #1, partition #0"
514  * @return
515  */
516 
win32DiskDriveByDiskPartitionID(const QString & deviceID)517 WmiQuery::Item WmiDevice::win32DiskDriveByDiskPartitionID(const QString &deviceID){
518     WmiQuery::Item result;
519     QString id = deviceID;
520     QString query("ASSOCIATORS OF {Win32_DiskPartition.DeviceID='"+ id +"'} WHERE AssocClass = Win32_DiskDriveToDiskPartition");
521     WmiQuery::ItemList items = WmiQuery::instance().sendQuery(query);
522     if(items.length()>0){
523         result = items[0];
524     }
525     return result;
526 }
527 
528 /**
529  * @brief WmiDevice::win32LogicalDiskByDiskPartitionID
530  * @param deviceID something like "disk #1, partition #0"
531  * @return
532  */
533 
win32LogicalDiskByDiskPartitionID(const QString & deviceID)534 WmiQuery::Item WmiDevice::win32LogicalDiskByDiskPartitionID(const QString &deviceID){
535     WmiQuery::Item result;
536     QString id = deviceID;
537     QString query("ASSOCIATORS OF {Win32_DiskPartition.DeviceID='" + id + "'} WHERE AssocClass = Win32_LogicalDiskToPartition");
538     WmiQuery::ItemList items = WmiQuery::instance().sendQuery(query);
539         if(items.length()>0){
540             result = items[0];
541         }
542     return result;
543 }
544 
545 /**
546  * @brief WmiDevice::win32DiskPartitionByDriveLetter
547  * @param driveLetter something lik "D:"
548  * @return
549  */
550 
win32DiskPartitionByDriveLetter(const QString & driveLetter)551 WmiQuery::Item WmiDevice::win32DiskPartitionByDriveLetter(const QString &driveLetter){
552     WmiQuery::Item result;
553     QString id = driveLetter;
554     QString query("ASSOCIATORS OF {Win32_LogicalDisk.DeviceID='" + id + "'} WHERE AssocClass = Win32_LogicalDiskToPartition");
555     WmiQuery::ItemList items = WmiQuery::instance().sendQuery(query);
556         if(items.length()>0){
557             result = items[0];
558         }
559     return result;
560 }
561 
562 /**
563  * @brief WmiDevice::win32LogicalDiskByDriveLetter
564  * @param driveLetter something lik "D:"
565  * @return
566  */
567 
win32LogicalDiskByDriveLetter(const QString & driveLetter)568 WmiQuery::Item WmiDevice::win32LogicalDiskByDriveLetter(const QString &driveLetter){
569     WmiQuery::Item result;
570     QString id = driveLetter;
571     QString query("SELECT * FROM Win32_LogicalDisk WHERE DeviceID='"+id+"'");
572     WmiQuery::ItemList items = WmiQuery::instance().sendQuery(query);
573         if(items.length()>0){
574             result = items[0];
575         }
576     return result;
577 }
578 
allProperties() const579 QMap<QString, QVariant> WmiDevice::allProperties() const
580 {
581     WmiQuery::Item item = d->sendQuery();
582 
583     return item.getAllProperties();
584 }
585 
propertyExists(const QString & key) const586 bool WmiDevice::propertyExists(const QString &key) const
587 {
588     WmiQuery::Item item = d->sendQuery();
589     const bool isEmpty = item.getProperty( key ).isValid();
590     return isEmpty;
591 }
592 
queryDeviceInterface(const Solid::DeviceInterface::Type & type) const593 bool WmiDevice::queryDeviceInterface(const Solid::DeviceInterface::Type &type) const
594 {
595     // Special cases not matching with WMI capabilities
596     if (type==Solid::DeviceInterface::GenericInterface) {
597         return true;
598     }
599 
600     return d->interfaceList.contains(type);
601 }
602 
createDeviceInterface(const Solid::DeviceInterface::Type & type)603 QObject *WmiDevice::createDeviceInterface(const Solid::DeviceInterface::Type &type)
604 {
605     if (!queryDeviceInterface(type)) {
606         return 0;
607     }
608 
609     DeviceInterface *iface = 0;
610 
611     switch (type)
612     {
613     case Solid::DeviceInterface::GenericInterface:
614         iface = new GenericInterface(this);
615         break;
616     //case Solid::DeviceInterface::Processor:
617     //    iface = new Processor(this);
618     //    break;
619     case Solid::DeviceInterface::Block:
620         iface = new Block(this);
621         break;
622     case Solid::DeviceInterface::StorageAccess:
623         iface = new StorageAccess(this);
624         break;
625     case Solid::DeviceInterface::StorageDrive:
626         iface = new Storage(this);
627         break;
628     case Solid::DeviceInterface::OpticalDrive:
629         iface = new Cdrom(this);
630         break;
631     case Solid::DeviceInterface::StorageVolume:
632         iface = new Volume(this);
633         break;
634     case Solid::DeviceInterface::OpticalDisc:
635         iface = new OpticalDisc(this);
636         break;
637     //case Solid::DeviceInterface::Camera:
638     //    iface = new Camera(this);
639     //    break;
640     case Solid::DeviceInterface::PortableMediaPlayer:
641         iface = new PortableMediaPlayer(this);
642         break;
643     /*case Solid::DeviceInterface::NetworkInterface:
644         iface = new NetworkInterface(this);
645         break;
646     case Solid::DeviceInterface::AcAdapter:
647         iface = new AcAdapter(this);
648         break;
649     case Solid::DeviceInterface::Battery:
650         iface = new Battery(this);
651         break;
652     case Solid::DeviceInterface::Button:
653         iface = new Button(this);
654         break;
655     case Solid::DeviceInterface::AudioInterface:
656         iface = new AudioInterface(this);
657         break;
658     case Solid::DeviceInterface::DvbInterface:
659         iface = new DvbInterface(this);
660         break;
661     case Solid::DeviceInterface::Video:
662         iface = new Video(this);
663         break;
664     */
665     case Solid::DeviceInterface::Unknown:
666     case Solid::DeviceInterface::Last:
667         break;
668     }
669 
670     return iface;
671 }
672 
slotPropertyModified(int,const QList<ChangeDescription> & changes)673 void WmiDevice::slotPropertyModified(int /*count */, const QList<ChangeDescription> &changes)
674 {
675     QMap<QString,int> result;
676 
677     foreach (const ChangeDescription &change, changes)
678     {
679         QString key = change.key;
680         bool added = change.added;
681         bool removed = change.removed;
682 
683         Solid::GenericInterface::PropertyChange type = Solid::GenericInterface::PropertyModified;
684 
685         if (added)
686         {
687             type = Solid::GenericInterface::PropertyAdded;
688         }
689         else if (removed)
690         {
691             type = Solid::GenericInterface::PropertyRemoved;
692         }
693 
694         result[key] = type;
695     }
696 
697     emit propertyChanged(result);
698 }
699 
slotCondition(const QString & condition,const QString & reason)700 void WmiDevice::slotCondition(const QString &condition, const QString &reason)
701 {
702     emit conditionRaised(condition, reason);
703 }
704 
705 #include "backends/wmi/moc_wmidevice.cpp"
706