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