f751789 · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

update the InputInfo snapshot

f751789Michael Zanetti11 years ago

plugins/Unity/InputInfo/CMakeLists.txt+1−1

compare with xenial

unifiedsplit

@@ -21,7 +21,7 @@ include_directories(

21set(InputInfo_SOURCES

22 plugin.cpp

23 qinputinfo.cpp

24− qdeclarativeinputdeviceinfo.cpp

24+ qdeclarativeinputdevicemodel.cpp

25 linux/qinputdeviceinfo_linux.cpp

26)

plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux.cpp+131−83

@@ -47,39 +47,46 @@

47#include <QDebug>

48#include <QSocketNotifier>

49#include <QTimer>

50+#include <QDir>

51−QInputDeviceInfoPrivate::QInputDeviceInfoPrivate(QObject *parent) :

52+QInputDeviceManagerPrivate::QInputDeviceManagerPrivate(QObject *parent) :

52− QObject(parent)

53+ QObject(parent),

53− , udev(0)

54+ currentFilter(QInputDevice::Unknown),

55+ udevice(0)

54{

56{

55− QTimer::singleShot(250, this, &QInputDeviceInfoPrivate::init);

57+ QTimer::singleShot(250,this,SLOT(init()));

56}

58}

58−void QInputDeviceInfoPrivate::init()

60+QInputDeviceManagerPrivate::~QInputDeviceManagerPrivate()

59{

61{

60− if (!udev)

62+ udev_unref(udevice);

63+ udev_monitor_unref(udevMonitor);

64+}

65+

66+void QInputDeviceManagerPrivate::init()

67+{

68+ if (!udevice)

61− udev = udev_new();

69+ udevice = udev_new();

63− struct udev_list_entry *devices, *dev_list_entry;

71+ udev_list_entry *devices;

72+ udev_list_entry *dev_list_entry;

64− struct udev_device *dev;

73+ udev_device *dev;

66 QString subsystem = QStringLiteral("input");

75 QString subsystem = QStringLiteral("input");

67 struct udev_enumerate *enumerate = 0;

76 struct udev_enumerate *enumerate = 0;

69− if (udev) {

78+ if (udevice) {

71− udevMonitor = udev_monitor_new_from_netlink(udev, "udev");

80+ udevMonitor = udev_monitor_new_from_netlink(udevice, "udev");

72 udev_monitor_filter_add_match_subsystem_devtype(udevMonitor, subsystem.toLatin1(), NULL);

81 udev_monitor_filter_add_match_subsystem_devtype(udevMonitor, subsystem.toLatin1(), NULL);

73− enumerate = udev_enumerate_new(udev);

82+ enumerate = udev_enumerate_new(udevice);

74 udev_enumerate_add_match_subsystem(enumerate, subsystem.toLatin1());

83 udev_enumerate_add_match_subsystem(enumerate, subsystem.toLatin1());

76−

77 udev_monitor_enable_receiving(udevMonitor);

85 udev_monitor_enable_receiving(udevMonitor);

78 notifierFd = udev_monitor_get_fd(udevMonitor);

86 notifierFd = udev_monitor_get_fd(udevMonitor);

80 notifier = new QSocketNotifier(notifierFd, QSocketNotifier::Read, this);

88 notifier = new QSocketNotifier(notifierFd, QSocketNotifier::Read, this);

81− connect(notifier, &QSocketNotifier::activated, this, &QInputDeviceInfoPrivate::onUDevChanges);

89+ connect(notifier, SIGNAL(activated(int)), this, SLOT(onUDevChanges()));

82−

84 udev_enumerate_scan_devices(enumerate);

91 udev_enumerate_scan_devices(enumerate);

85 devices = udev_enumerate_get_list_entry(enumerate);

92 devices = udev_enumerate_get_list_entry(enumerate);

@@ -88,78 +95,80 @@ void QInputDeviceInfoPrivate::init()

88 const char *path;

95 const char *path;

89 path = udev_list_entry_get_name(dev_list_entry);

96 path = udev_list_entry_get_name(dev_list_entry);

91− dev = udev_device_new_from_syspath(udev, path);

98+ dev = udev_device_new_from_syspath(udevice, path);

92−

93− QString eventPath = QString::fromLatin1(udev_device_get_sysname(dev));

94−

95 if (qstrcmp(udev_device_get_subsystem(dev), "input") == 0 ) {

99 if (qstrcmp(udev_device_get_subsystem(dev), "input") == 0 ) {

96−

97− if (eventPath.contains(QStringLiteral("event"))) {

98− eventPath.prepend(QStringLiteral("/dev/input/"));

99−

100− QInputDevice *iDevice = addDevice(eventPath);

100+ QInputDevice *iDevice = addDevice(dev);

101− if (!iDevice)

101+ if (iDevice && !iDevice->devicePath().isEmpty()) {

102− continue;

103−

104− iDevice->setTypes(getInputTypes(dev));

105−

106− if (iDevice->switches().count() > 0 && iDevice->buttons().count() == 0)

107− iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Switch);

108−

109− if (iDevice->buttons().count() > 0 && iDevice->types() == QInputDeviceInfo::Unknown)

110− iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Button);

111−

112− deviceList.append(iDevice);

113− deviceMap.insert(eventPath,iDevice);

102+ deviceMap.insert(iDevice->devicePath(),iDevice);

114− Q_EMIT newDevice(eventPath);

115−

116 }

103 }

117 }

104 }

105+ udev_device_unref(dev);

118 }

106 }

119 udev_enumerate_unref(enumerate);

107 udev_enumerate_unref(enumerate);

120 }

108 }

109+ // udev_unref(udevice);

110+ Q_FOREACH (const QString &devicePath, deviceMap.keys()) {

111+ Q_EMIT deviceAdded(devicePath);

112+ }

121 Q_EMIT ready();

113 Q_EMIT ready();

122}

114}

123

115

124−QInputDeviceInfo::InputTypes QInputDeviceInfoPrivate::getInputTypes( struct udev_device *dev)

116+QInputDevice::InputTypeFlags QInputDeviceManagerPrivate::getInputTypeFlags(struct udev_device *dev)

125{

117{

126− QInputDeviceInfo::InputTypes types = QInputDeviceInfo::Unknown;

118+ QInputDevice::InputTypeFlags flags = QInputDevice::Unknown;

127− if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD"), "1") == 0 )

119+ if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_KEY"), "1") == 0 ) {

128− types |= QInputDeviceInfo::Keyboard;

120+ flags |= QInputDevice::Button;

129−

121+ }

130− if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_MOUSE"), "1") == 0)

122+ if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_MOUSE"), "1") == 0) {

131− types |= QInputDeviceInfo::Mouse;

123+ flags |= QInputDevice::Mouse;

132−

124+ }

133− if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TOUCHPAD"), "1") == 0)

125+ if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TOUCHPAD"), "1") == 0) {

134− types |= QInputDeviceInfo::TouchPad;

126+ flags |= QInputDevice::TouchPad;

135−

127+ }

136 if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TOUCHSCREEN"), "1") == 0

128 if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TOUCHSCREEN"), "1") == 0

137− || qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TABLET"), "1") == 0)

129+ || qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TABLET"), "1") == 0) {

138− types |= QInputDeviceInfo::TouchScreen;

130+ flags |= QInputDevice::TouchScreen;

131+ }

132+ if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD"), "1") == 0 ) {

133+ flags |= QInputDevice::Keyboard;

134+ }

135+ if (!QString::fromLatin1(udev_device_get_property_value(dev, "SW")).isEmpty()) {

136+ flags |= QInputDevice::Switch;

137+ }

139

138

140− return types;

139+ return flags;

141}

140}

142

141

143−QInputDevice *QInputDeviceInfoPrivate::addDevice(const QString &path)

142+QInputDevice *QInputDeviceManagerPrivate::addDevice(struct udev_device *udev)

144{

143{

145− QInputDevice *inputDevice = new QInputDevice(this);

144+ QString eventPath = QString::fromLatin1(udev_device_get_sysname(udev));

146− inputDevice->setDevicePath(path);

147

145

146+ if (eventPath.contains(QStringLiteral("event")))

147+ eventPath.prepend(QStringLiteral("/dev/input/"));

148+

149+ if (deviceMap.contains(eventPath)) {

150+ return Q_NULLPTR;

151+ }

148 struct libevdev *dev = NULL;

152 struct libevdev *dev = NULL;

149 int fd;

153 int fd;

150 int rc = 1;

154 int rc = 1;

151− fd = open(path.toLatin1(), O_RDONLY|O_NONBLOCK);

155+ QInputDevice *inputDevice;

156+ inputDevice = addUdevDevice(udev);

157+ if (!inputDevice) {

158+ return Q_NULLPTR;

159+ }

160+ eventPath = inputDevice->devicePath();

152

161

162+ fd = open(eventPath.toLatin1(), O_RDONLY|O_NONBLOCK);

153 if (fd == -1) {

163 if (fd == -1) {

154 return inputDevice;

164 return inputDevice;

155 }

165 }

156 rc = libevdev_new_from_fd(fd, &dev);

166 rc = libevdev_new_from_fd(fd, &dev);

157 if (rc < 0) {

167 if (rc < 0) {

158 qWarning() << "Failed to init libevdev ("<< strerror(-rc) << ")";

168 qWarning() << "Failed to init libevdev ("<< strerror(-rc) << ")";

159− return inputDevice;

169+ return Q_NULLPTR;

160 }

170 }

161

171

162− inputDevice->setName(QString::fromLatin1(libevdev_get_name(dev)));

163 for (int i = 0; i < EV_MAX; i++) {

172 for (int i = 0; i < EV_MAX; i++) {

164 if (i == EV_KEY || i == EV_SW || i == EV_REL

173 if (i == EV_KEY || i == EV_SW || i == EV_REL

165 || i == EV_REL || i == EV_ABS) {

174 || i == EV_REL || i == EV_ABS) {

@@ -183,54 +192,93 @@ QInputDevice *QInputDeviceInfoPrivate::addDevice(const QString &path)

183 }

192 }

184 }

193 }

185 }

194 }

195+

186 return inputDevice;

196 return inputDevice;

187}

197}

188

198

199+void QInputDeviceManagerPrivate::addDetails(struct udev_device *)

200+{

201+}

202+

189−void QInputDeviceInfoPrivate::removeDevice(const QString &path)

203+void QInputDeviceManagerPrivate::removeDevice(const QString &path)

190{

204{

191− for (int i = 0; i < deviceList.size(); ++i) {

205+ // this path is not a full evdev path

206+ Q_FOREACH (const QString devicePath, deviceMap.keys()) {

192− if (deviceList.at(i)->devicePath() == path) {

207+ if (devicePath.contains(path)) {

193− delete deviceList.takeAt(i);

194− deviceMap.remove(path);

208+ deviceMap.remove(devicePath);

195− Q_EMIT deviceRemoved(path);

209+ Q_EMIT deviceRemoved(devicePath);

196 }

210 }

197 }

211 }

198}

212}

199

213

200−void QInputDeviceInfoPrivate::onUDevChanges()

214+QInputDevice *QInputDeviceManagerPrivate::addUdevDevice(struct udev_device *udev)

201{

215{

216+ QInputDevice *iDevice;

217+

218+ struct udev_list_entry *list;

219+ struct udev_list_entry *node;

220+

221+ list = udev_device_get_properties_list_entry (udev);

222+ QString syspath = QString::fromLatin1(udev_device_get_syspath(udev));

223+ QDir sysdir(syspath);

224+

225+ QStringList infoList = sysdir.entryList(QStringList() << QStringLiteral("event*"),QDir::Dirs);

226+

227+ if (infoList.count() > 0) {

228+ QString token = infoList.at(0);

229+

230+ token.prepend(QStringLiteral("/dev/input/"));

231+ iDevice = new QInputDevice(this);

232+ iDevice->setDevicePath(token);

233+ } else {

234+ return Q_NULLPTR;

235+ }

236+ udev_list_entry_foreach (node, list) {

237+

238+ QString key = QString::fromLatin1(udev_list_entry_get_name(node));

239+ QString value = QString::fromLatin1(udev_list_entry_get_value(node));

240+

241+ if (key == QStringLiteral("NAME")) {

242+ iDevice->setName(value.remove(QStringLiteral("\"")));

243+ }

244+ }

245+ iDevice->setType(getInputTypeFlags(udev));

246+ return iDevice;

247+}

248+

249+void QInputDeviceManagerPrivate::onUDevChanges()

250+{

251+ if (!udevMonitor)

252+ return;

253+

202− struct udev_device *dev = udev_monitor_receive_device(udevMonitor);

254+ udev_device *dev = udev_monitor_receive_device(udevMonitor);

255+

203 if (dev) {

256 if (dev) {

204 if (qstrcmp(udev_device_get_subsystem(dev), "input") == 0 ) {

257 if (qstrcmp(udev_device_get_subsystem(dev), "input") == 0 ) {

205 QString eventPath = QString::fromLatin1(udev_device_get_sysname(dev));

258 QString eventPath = QString::fromLatin1(udev_device_get_sysname(dev));

206

259

207− if (eventPath.contains(QStringLiteral("input")))

208− return;

209−

210 QString action = QString::fromStdString(udev_device_get_action(dev));

260 QString action = QString::fromStdString(udev_device_get_action(dev));

211

261

212 if (!eventPath.contains(QStringLiteral("/dev/input/")))

262 if (!eventPath.contains(QStringLiteral("/dev/input/")))

213 eventPath.prepend(QStringLiteral("/dev/input/"));

263 eventPath.prepend(QStringLiteral("/dev/input/"));

214

264

215 if (action == QStringLiteral("add")) {

265 if (action == QStringLiteral("add")) {

216−

266+ if (deviceMap.contains(eventPath)){

217− QInputDevice *iDevice = addDevice(eventPath);

218− if (!iDevice)

219− return;

220−

221− iDevice->setTypes(getInputTypes(dev));

222 udev_device_unref(dev);

267 udev_device_unref(dev);

268+ return;

269+ }

223

270

224− if (iDevice->switches().count() > 0 && iDevice->buttons().count() == 0)

271+ QInputDevice *iDevice = addDevice(dev);

225− iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Switch);

272+ if (!iDevice) {

226−

273+ delete iDevice;

227− if (iDevice->buttons().count() > 0 && iDevice->types() == QInputDeviceInfo::Unknown)

274+ return;

228− iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Button);

275+ }

276+ iDevice->setType(getInputTypeFlags(dev));

277+ udev_device_unref(dev);

229

278

230− deviceList.append(iDevice);

231 deviceMap.insert(eventPath,iDevice);

279 deviceMap.insert(eventPath,iDevice);

232

280

233− Q_EMIT newDevice(eventPath);

281+ Q_EMIT deviceAdded(eventPath);

234

282

235 } else if (action == QStringLiteral("remove")) {

283 } else if (action == QStringLiteral("remove")) {

236 removeDevice(eventPath);

284 removeDevice(eventPath);

plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux_p.h+13−6

@@ -58,30 +58,37 @@ public:

58 QList <int> switches;

59 QList <int> relativeAxis;

60 QList <int> absoluteAxis;

61− QInputDeviceInfo::InputTypes types;

61+ QInputDevice::InputTypeFlags type;

62};

64−class QInputDeviceInfoPrivate : public QObject

64+class QInputDeviceManagerPrivate : public QObject

65{

66 Q_OBJECT

67public:

68− explicit QInputDeviceInfoPrivate(QObject *parent = 0);

68+ explicit QInputDeviceManagerPrivate(QObject *parent = 0);

69+ ~QInputDeviceManagerPrivate();

69 QVector <QInputDevice *> deviceList;

70 QVector <QInputDevice *> deviceList;

70 QMap <QString, QInputDevice *> deviceMap;

71 QMap <QString, QInputDevice *> deviceMap;

72+ static QInputDeviceManagerPrivate * instance();

73+ QInputDevice::InputType currentFilter;

72Q_SIGNALS:

75Q_SIGNALS:

73− void newDevice(const QString &);

76+ void deviceAdded(const QString &);

74 void deviceRemoved(const QString &);

77 void deviceRemoved(const QString &);

75 void ready();

78 void ready();

77private:

80private:

78− struct udev *udev;

81+ QInputDevice *addDevice(struct udev_device *udev);

82+ QInputDevice *addUdevDevice(struct udev_device *);

83+

79 QInputDevice *addDevice(const QString &path);

84 QInputDevice *addDevice(const QString &path);

80 void removeDevice(const QString &path);

85 void removeDevice(const QString &path);

81 QSocketNotifier *notifier;

86 QSocketNotifier *notifier;

82 int notifierFd;

87 int notifierFd;

83 struct udev_monitor *udevMonitor;

88 struct udev_monitor *udevMonitor;

84− QInputDeviceInfo::InputTypes getInputTypes( struct udev_device *);

89+ QInputDevice::InputTypeFlags getInputTypeFlags(struct udev_device *);

90+ struct udev *udevice;

91+ void addDetails(struct udev_device *);

86private Q_SLOTS:

93private Q_SLOTS:

87 void onUDevChanges();

94 void onUDevChanges();

plugins/Unity/InputInfo/plugin.cpp+2−2

@@ -21,12 +21,12 @@

21#include "plugin.h"

23// local

24−#include "qdeclarativeinputdeviceinfo_p.h"

24+#include "qdeclarativeinputdevicemodel_p.h"

26void InputInfoPlugin::registerTypes(const char *uri)

27{

28 int major = 0;

29 int minor = 1;

30− qmlRegisterType<QDeclarativeInputDeviceInfo>(uri, major, minor, "InputDeviceInfo");

30+ qmlRegisterType<QDeclarativeInputDeviceModel>(uri, major, minor, "InputDeviceModel");

31 qmlRegisterType<QInputDevice>(uri, major, minor, "InputInfo");

32}

plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo.cpp → plugins/Unity/InputInfo/qdeclarativeinputdevicemodel.cpprenamed+78−24

@@ -38,40 +38,64 @@

38** $QT_END_LICENSE$

39**

40****************************************************************************/

41−#include "qdeclarativeinputdeviceinfo_p.h"

41+#include "qdeclarativeinputdevicemodel_p.h"

42+#include "qinputinfo.h"

43−QDeclarativeInputDeviceInfo::QDeclarativeInputDeviceInfo(QObject *parent) :

44+QDeclarativeInputDeviceModel::QDeclarativeInputDeviceModel(QObject *parent) :

44 QAbstractListModel(parent),

45 QAbstractListModel(parent),

45− deviceInfo(new QInputDeviceInfo)

46+ deviceInfo(new QInputDeviceManager),

47+ currentFilter(QInputDevice::Unknown)

46{

48{

47− connect(deviceInfo, &QInputDeviceInfo::ready, this, &QDeclarativeInputDeviceInfo::updateDeviceList);

49+ connect(deviceInfo,SIGNAL(ready()),this,SLOT(updateDeviceList()));

48− connect(deviceInfo, &QInputDeviceInfo::deviceAdded,this,&QDeclarativeInputDeviceInfo::addedDevice);

50+ connect(deviceInfo, &QInputDeviceManager::deviceAdded,this,&QDeclarativeInputDeviceModel::addedDevice);

49− connect(deviceInfo, &QInputDeviceInfo::deviceRemoved,this,&QDeclarativeInputDeviceInfo::removedDevice);

51+ connect(deviceInfo, &QInputDeviceManager::deviceRemoved,this,&QDeclarativeInputDeviceModel::removedDevice);

50}

52}

52−QDeclarativeInputDeviceInfo::~QDeclarativeInputDeviceInfo()

54+QDeclarativeInputDeviceModel::~QDeclarativeInputDeviceModel()

53{

55{

54 delete deviceInfo;

56 delete deviceInfo;

55}

57}

57−QVariant QDeclarativeInputDeviceInfo::data(const QModelIndex &index, int role) const

59+QVariant QDeclarativeInputDeviceModel::data(const QModelIndex &index, int role) const

58{

60{

59 switch (role) {

61 switch (role) {

60 case ServiceRole:

62 case ServiceRole:

61 return QVariant::fromValue(static_cast<QObject *>(inputDevices.value(index.row())));

63 return QVariant::fromValue(static_cast<QObject *>(inputDevices.value(index.row())));

64+ break;

65+ case NameRole:

66+ return QVariant::fromValue(static_cast<QString>(inputDevices.value(index.row())->name()));

67+ break;

68+ case DevicePathRole:

69+ return QVariant::fromValue(static_cast<QString>(inputDevices.value(index.row())->devicePath()));

70+ break;

71+ case ButtonsRole:

72+ return QVariant::fromValue(static_cast<QList <int> >(inputDevices.value(index.row())->buttons()));

73+ break;

74+ case SwitchesRole:

75+ return QVariant::fromValue(static_cast<QList <int> >(inputDevices.value(index.row())->switches()));

76+ break;

77+ case RelativeAxisRole:

78+ return QVariant::fromValue(static_cast<QList <int> >(inputDevices.value(index.row())->relativeAxis()));

79+ break;

80+ case AbsoluteAxisRole:

81+ return QVariant::fromValue(static_cast<QList <int> >(inputDevices.value(index.row())->absoluteAxis()));

82+ break;

83+ case TypesRole:

84+ return QVariant::fromValue(static_cast<int>(inputDevices.value(index.row())->type()));

85+ break;

62− }

86+ };

64 return QVariant();

88 return QVariant();

65}

89}

67−int QDeclarativeInputDeviceInfo::rowCount(const QModelIndex &parent) const

91+int QDeclarativeInputDeviceModel::rowCount(const QModelIndex &parent) const

68{

92{

69 Q_UNUSED(parent);

93 Q_UNUSED(parent);

71 return inputDevices.count();

95 return inputDevices.count();

72}

96}

74−int QDeclarativeInputDeviceInfo::indexOf(const QString &devicePath) const

98+int QDeclarativeInputDeviceModel::indexOf(const QString &devicePath) const

75{

99{

76 int idx(-1);

100 int idx(-1);

77 Q_FOREACH (QInputDevice *device, inputDevices) {

101 Q_FOREACH (QInputDevice *device, inputDevices) {

@@ -82,26 +106,27 @@ int QDeclarativeInputDeviceInfo::indexOf(const QString &devicePath) const

82 return -1;

106 return -1;

83}

107}

108

85−QInputDevice *QDeclarativeInputDeviceInfo::get(int index) const

109+QInputDevice *QDeclarativeInputDeviceModel::get(int index) const

86{

110{

87 if (index < 0 || index > inputDevices.count())

111 if (index < 0 || index > inputDevices.count())

88 return 0;

112 return 0;

89 return inputDevices.value(index);

113 return inputDevices.value(index);

90}

114}

115

92−void QDeclarativeInputDeviceInfo::updateDeviceList()

116+void QDeclarativeInputDeviceModel::updateDeviceList()

93{

117{

94− QVector <QInputDevice *> newDevices = deviceInfo->deviceList();

118+ QVector <QInputDevice *> newDevices = deviceInfo->deviceListOfType(currentFilter);

119

96 int numNew = newDevices.count();

120 int numNew = newDevices.count();

121

98 for (int i = 0; i < numNew; i++) {

122 for (int i = 0; i < numNew; i++) {

99 int j = inputDevices.indexOf(newDevices.value(i));

123 int j = inputDevices.indexOf(newDevices.value(i));

124+

100 if (j == -1) {

125 if (j == -1) {

101− // not found -> remove from list

102 beginInsertRows(QModelIndex(), i, i);

126 beginInsertRows(QModelIndex(), i, i);

103 inputDevices.insert(i, newDevices.value(i));

127 inputDevices.insert(i, newDevices.value(i));

104 endInsertRows();

128 endInsertRows();

129+ Q_EMIT countChanged();

105 } else if (i != j) {

130 } else if (i != j) {

106 // changed its position -> move it

131 // changed its position -> move it

107 QInputDevice* device = inputDevices.value(j);

132 QInputDevice* device = inputDevices.value(j);

@@ -109,10 +134,10 @@ void QDeclarativeInputDeviceInfo::updateDeviceList()

109 inputDevices.remove(j);

134 inputDevices.remove(j);

110 inputDevices.insert(i, device);

135 inputDevices.insert(i, device);

111 endMoveRows();

136 endMoveRows();

137+ Q_EMIT countChanged();

112− } else {

138+ } //else {

113− QModelIndex changedIndex(this->index(j, 0, QModelIndex()));

139+ QModelIndex changedIndex(this->index(j, 0, QModelIndex()));

114− Q_EMIT dataChanged(changedIndex, changedIndex);

140+ Q_EMIT dataChanged(changedIndex, changedIndex);

115− }

116 }

141 }

117

142

118 int numOld = inputDevices.count();

143 int numOld = inputDevices.count();

@@ -120,24 +145,53 @@ void QDeclarativeInputDeviceInfo::updateDeviceList()

120 beginRemoveRows(QModelIndex(), numNew, numOld - 1);

145 beginRemoveRows(QModelIndex(), numNew, numOld - 1);

121 inputDevices.remove(numNew, numOld - numNew);

146 inputDevices.remove(numNew, numOld - numNew);

122 endRemoveRows();

147 endRemoveRows();

148+ Q_EMIT countChanged();

123 }

149 }

124}

150}

125

151

126−void QDeclarativeInputDeviceInfo::addedDevice(const QString &devicePath)

152+void QDeclarativeInputDeviceModel::addedDevice(const QString &devicePath)

127{

153{

128 updateDeviceList();

154 updateDeviceList();

129− Q_EMIT newDevice(devicePath);

155+ Q_EMIT deviceAdded(devicePath);

130}

156}

131

157

132−void QDeclarativeInputDeviceInfo::removedDevice(const QString &devicePath)

158+void QDeclarativeInputDeviceModel::removedDevice(const QString &devicePath)

133{

159{

134 updateDeviceList();

160 updateDeviceList();

135 Q_EMIT deviceRemoved(devicePath);

161 Q_EMIT deviceRemoved(devicePath);

136}

162}

137

163

138−QHash<int, QByteArray> QDeclarativeInputDeviceInfo::roleNames() const

164+QHash<int,QByteArray> QDeclarativeInputDeviceModel::roleNames() const

139{

165{

140 QHash<int, QByteArray> roles;

166 QHash<int, QByteArray> roles;

141− roles.insert(ServiceRole, "service");

167+ roles[NameRole] = "name";

168+ roles[DevicePathRole] = "devicePath";

169+ roles[ButtonsRole] = "buttons";

170+ roles[SwitchesRole] = "switches";

171+ roles[RelativeAxisRole] = "rAxis";

172+ roles[AbsoluteAxisRole] = "aAxis";

173+ roles[TypesRole] = "types";

142 return roles;

174 return roles;

143}

175}

176+

177+/*

178+ * Returns the currently set device filter.

179+ * */

180+QInputDevice::InputType QDeclarativeInputDeviceModel::deviceFilter()

181+{

182+ return currentFilter;

183+}

184+

185+/*

186+ * Sets the current input device filter to filter.

187+ * */

188+void QDeclarativeInputDeviceModel::setDeviceFilter(QInputDevice::InputType filter)

189+{

190+ if (filter != currentFilter) {

191+ deviceInfo->setDeviceFilter(filter);

192+ currentFilter = filter;

193+ updateDeviceList();

194+ Q_EMIT deviceFilterChanged(filter);

195+ }

196+}

197+

plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo_p.h → plugins/Unity/InputInfo/qdeclarativeinputdevicemodel_p.hrenamed+27−11

@@ -39,48 +39,64 @@

39**

40****************************************************************************/

42−#ifndef QDECLARATIVEINPUTDEVICEINFO_H

42+#ifndef QDECLARATIVEINPUTDEVICEMODEL_H

43−#define QDECLARATIVEINPUTDEVICEINFO_H

43+#define QDECLARATIVEINPUTDEVICEMODEL_H

45#include <QObject>

46#include <QAbstractListModel>

47#include "qinputinfo.h"

49−class QDeclarativeInputDeviceInfo : public QAbstractListModel

49+class QDeclarativeInputDeviceModel : public QAbstractListModel

50{

51 Q_OBJECT

52− Q_DISABLE_COPY(QDeclarativeInputDeviceInfo)

52+ Q_DISABLE_COPY(QDeclarativeInputDeviceModel)

53+ Q_PROPERTY(QInputDevice::InputType deviceFilter READ deviceFilter WRITE setDeviceFilter NOTIFY deviceFilterChanged)

54+

55+ Q_PROPERTY(int count READ rowCount NOTIFY countChanged)

54public:

57public:

55 enum ItemRoles {

58 enum ItemRoles {

56− ServiceRole = Qt::UserRole + 1

59+ ServiceRole = Qt::UserRole + 1,

60+ NameRole,

61+ DevicePathRole,

62+ ButtonsRole,

63+ SwitchesRole,

64+ RelativeAxisRole,

65+ AbsoluteAxisRole,

66+ TypesRole

57 };

67 };

59− explicit QDeclarativeInputDeviceInfo(QObject *parent = 0);

69+ explicit QDeclarativeInputDeviceModel(QObject *parent = 0);

60− virtual ~QDeclarativeInputDeviceInfo();

70+ virtual ~QDeclarativeInputDeviceModel();

62 QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;

72 QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;

63 int rowCount(const QModelIndex &parent = QModelIndex()) const;

73 int rowCount(const QModelIndex &parent = QModelIndex()) const;

65− QHash<int, QByteArray> roleNames() const;

75+ void setDeviceFilter(QInputDevice::InputType filter);

76+ QInputDevice::InputType deviceFilter();

67 Q_INVOKABLE int indexOf(const QString &devicePath) const;

78 Q_INVOKABLE int indexOf(const QString &devicePath) const;

69 Q_INVOKABLE QInputDevice *get(int index) const;

80 Q_INVOKABLE QInputDevice *get(int index) const;

81+ QHash<int, QByteArray> roleNames() const;

71Q_SIGNALS:

83Q_SIGNALS:

72− void newDevice(const QString &devicePath);

84+ void deviceAdded(const QString &devicePath);

73 void deviceRemoved(const QString &devicePath);

85 void deviceRemoved(const QString &devicePath);

86+ void deviceFilterChanged(const QInputDevice::InputType filter);

87+ void countChanged();

75public Q_SLOTS:

89public Q_SLOTS:

76 void updateDeviceList();

90 void updateDeviceList();

77private:

91private:

78− QInputDeviceInfo *deviceInfo;

92+ QInputDeviceManager *deviceInfo;

79 QVector<QInputDevice *> inputDevices;

93 QVector<QInputDevice *> inputDevices;

94+ QInputDevice::InputType currentFilter;

95+

80private Q_SLOTS:

96private Q_SLOTS:

81 void addedDevice(const QString &);

97 void addedDevice(const QString &);

82 void removedDevice(const QString &path);

98 void removedDevice(const QString &path);

84};

100};

101

86−#endif // QDECLARATIVEINPUTDEVICEINFO_H

102+#endif // QDECLARATIVEINPUTDEVICEMODEL_H

plugins/Unity/InputInfo/qinputinfo.cpp+126−17

@@ -45,12 +45,19 @@

45#include "linux/qinputdeviceinfo_linux_p.h"

46#endif

48+Q_GLOBAL_STATIC(QInputDeviceManagerPrivate, inputDeviceManagerPrivate)

49+

48QT_BEGIN_NAMESPACE

50QT_BEGIN_NAMESPACE

52+QInputDeviceManagerPrivate * QInputDeviceManagerPrivate::instance()

53+{

54+ QInputDeviceManagerPrivate *priv = inputDeviceManagerPrivate();

55+ return priv;

56+}

51QInputDevicePrivate::QInputDevicePrivate(QObject *parent) :

58QInputDevicePrivate::QInputDevicePrivate(QObject *parent) :

52 QObject(parent),

59 QObject(parent),

53− types(QInputDeviceInfo::Unknown)

60+ type(QInputDevice::Unknown)

54{

61{

55}

62}

@@ -60,100 +67,202 @@ QInputDevice::QInputDevice(QObject *parent) :

60{

67{

61}

68}

70+/*

71+ * Returns the name of this input device.

72+ */

63QString QInputDevice::name() const

73QString QInputDevice::name() const

64{

74{

65 return d_ptr->name;

75 return d_ptr->name;

66}

76}

78+/*

79+ * Sets the name of this input device to \b name.

80+ */

68void QInputDevice::setName(const QString &name)

81void QInputDevice::setName(const QString &name)

69{

82{

70 d_ptr->name = name;

83 d_ptr->name = name;

71}

84}

86+/*

87+ * Returns the device path of this device.

88+ */

73QString QInputDevice::devicePath() const

89QString QInputDevice::devicePath() const

74{

90{

75 return d_ptr->devicePath;

91 return d_ptr->devicePath;

76}

92}

94+/*

95+ * Sets the device ppath of this device to /b path.

96+ */

78void QInputDevice::setDevicePath(const QString &path)

97void QInputDevice::setDevicePath(const QString &path)

79{

98{

80 d_ptr->devicePath = path;

99 d_ptr->devicePath = path;

81}

100}

101

102+/*

103+ * Returns the number of buttons this device has.

104+ */

83QList <int> QInputDevice::buttons() const

105QList <int> QInputDevice::buttons() const

84{

106{

85 return d_ptr->buttons;

107 return d_ptr->buttons;

86}

108}

109

110+/*

111+ * Adds a button

112+ */

88void QInputDevice::addButton(int buttonCode)

113void QInputDevice::addButton(int buttonCode)

89{

114{

90 d_ptr->buttons.append(buttonCode);

115 d_ptr->buttons.append(buttonCode);

91}

116}

117

118+/*

119+ * Returns the number of switch of this device.

120+ */

93QList <int> QInputDevice::switches() const

121QList <int> QInputDevice::switches() const

94{

122{

95 return d_ptr->switches;

123 return d_ptr->switches;

96}

124}

125

126+/*

127+ * Adds a switch

128+ */

98void QInputDevice::addSwitch(int switchCode)

129void QInputDevice::addSwitch(int switchCode)

99{

130{

100 d_ptr->switches.append(switchCode);

131 d_ptr->switches.append(switchCode);

101}

132}

102

133

134+/*

135+ * Returns a list of the relative axis of this device

136+ */

103QList <int> QInputDevice::relativeAxis() const

137QList <int> QInputDevice::relativeAxis() const

104{

138{

105 return d_ptr->relativeAxis;

139 return d_ptr->relativeAxis;

106}

140}

107

141

142+/*

143+ */

108void QInputDevice::addRelativeAxis(int axisCode)

144void QInputDevice::addRelativeAxis(int axisCode)

109{

145{

110 d_ptr->relativeAxis.append(axisCode);

146 d_ptr->relativeAxis.append(axisCode);

111}

147}

112

148

149+/*

150+ * Returns a list of the absolute axis of this device

151+ */

113QList <int> QInputDevice::absoluteAxis() const

152QList <int> QInputDevice::absoluteAxis() const

114{

153{

115 return d_ptr->absoluteAxis;

154 return d_ptr->absoluteAxis;

116}

155}

117

156

157+/*

158+ */

118void QInputDevice::addAbsoluteAxis(int axisCode)

159void QInputDevice::addAbsoluteAxis(int axisCode)

119{

160{

120 d_ptr->absoluteAxis.append(axisCode);

161 d_ptr->absoluteAxis.append(axisCode);

121}

162}

122

163

123−QInputDeviceInfo::InputTypes QInputDevice::types()

164+/*

165+ * Returns a QInputDevice::InputTypeFlags of all the types of types.

166+ */

167+QInputDevice::InputTypeFlags QInputDevice::type() const

124{

168{

125− return d_ptr->types;

169+ return d_ptr->type;

126}

170}

127

171

128−void QInputDevice::setTypes(QInputDeviceInfo::InputTypes types)

172+/*

173+ */

174+void QInputDevice::setType(QInputDevice::InputTypeFlags type) //? setTypes?

129{

175{

130− d_ptr->types = types;

176+ d_ptr->type = type;

131}

177}

132

178

133−

179+QInputDeviceManager::QInputDeviceManager(QObject *parent) :

134−QInputDeviceInfo::QInputDeviceInfo(QObject *parent) :

135 QObject(parent),

180 QObject(parent),

136− d_ptr(new QInputDeviceInfoPrivate(this))

181+ d_ptr(inputDeviceManagerPrivate)

137{

182{

138− connect(d_ptr, &QInputDeviceInfoPrivate::newDevice,this,&QInputDeviceInfo::addedDevice);

183+ connect(d_ptr, &QInputDeviceManagerPrivate::deviceAdded,this,&QInputDeviceManager::addedDevice);

139− connect(d_ptr, &QInputDeviceInfoPrivate::deviceRemoved,this,&QInputDeviceInfo::deviceRemoved);

184+ connect(d_ptr, &QInputDeviceManagerPrivate::deviceRemoved,this,&QInputDeviceManager::deviceRemoved);

140

185

141− connect(d_ptr, &QInputDeviceInfoPrivate::ready, this, &QInputDeviceInfo::ready);

186+ connect(d_ptr,SIGNAL(ready()),this,SIGNAL(ready()));

142}

187}

143

188

144−QVector <QInputDevice *> QInputDeviceInfo::deviceList()

189+/*

190+ * Returns a QMap of known input devices.

191+ */

192+QMap <QString, QInputDevice *> QInputDeviceManager::deviceMap()

145{

193{

146− return d_ptr->deviceList;

194+ return d_ptr->deviceMap;

147}

195}

148

196

149−QMap <QString, QInputDevice *> QInputDeviceInfo::deviceMap()

197+/*

198+ */

199+void QInputDeviceManager::addedDevice(const QString & devicePath)

150{

200{

151− return d_ptr->deviceMap;

201+ Q_EMIT deviceAdded(devicePath);

152}

202}

153

203

154−void QInputDeviceInfo::addedDevice(const QString & devicePath)

204+/*

205+ * Returns a QVector of InputDevices of type filter

206+ * */

207+QVector <QInputDevice *> QInputDeviceManager::deviceListOfType(QInputDevice::InputType filter)

155{

208{

156− Q_EMIT deviceAdded(devicePath);

209+ QVector <QInputDevice *> dList;

210+ QMapIterator<QString, QInputDevice *> i(d_ptr->deviceMap);

211+ while (i.hasNext()) {

212+ i.next();

213+ if (i.value()->type().testFlag(filter) || filter == QInputDevice::Unknown) {

214+ dList.append(i.value());

215+ }

216+ }

217+ return dList;

218+}

219+

220+/*

221+ * Returns the number of input devices with the currently set QInputDevice::InputType filter.

222+ * If no device filter has been set, returns number of all available input devices.

223+ * If filter has not been set, returns all available input devices

224+ */

225+int QInputDeviceManager::deviceCount() const

226+{

227+ return deviceCount(static_cast< QInputDevice::InputType >(d_ptr->currentFilter));

228+}

229+

230+/*

231+ * Returns the number of input devices of the type filter.

232+ */

233+int QInputDeviceManager::deviceCount(const QInputDevice::InputType filter) const

234+{

235+ int dList = 0;

236+ QMapIterator<QString, QInputDevice *> i(d_ptr->deviceMap);

237+ while (i.hasNext()) {

238+ i.next();

239+// qDebug() << i.value()->name() << i.value()->devicePath();

240+// qDebug() << i.value()->type() << i.value()->type().testFlag(filter);

241+

242+ if (i.value()->type().testFlag(filter)) {

243+ dList++;

244+ }

245+ }

246+ return dList;

247+}

248+

249+/*

250+ * Returns the currently set device filter.

251+ * */

252+QInputDevice::InputType QInputDeviceManager::deviceFilter()

253+{

254+ return d_ptr->currentFilter;

255+}

256+

257+/*

258+ * Sets the current input device filter to filter.

259+ * */

260+void QInputDeviceManager::setDeviceFilter(QInputDevice::InputType filter)

261+{

262+ if (filter != d_ptr->currentFilter) {

263+ d_ptr->currentFilter = filter;

264+ Q_EMIT deviceFilterChanged(filter);

265+ }

157}

266}

158

267

159QT_END_NAMESPACE

268QT_END_NAMESPACE

plugins/Unity/InputInfo/qinputinfo.h+57−56

@@ -42,21 +42,26 @@

42#ifndef QINPUTINFO_H

43#define QINPUTINFO_H

45+#include <QtSystemInfo/qsysteminfoglobal.h>

45#include <QObject>

46#include <QObject>

46#include <QVector>

47#include <QVector>

47#include <QMap>

48#include <QMap>

48#include <QSocketNotifier>

49#include <QSocketNotifier>

49#include <QDebug>

50#include <QDebug>

51−class QInputDeviceInfoPrivate;

52+class QInputDeviceManagerPrivate;

52class QInputDevicePrivate;

53class QInputDevicePrivate;

53class QInputDevice;

54class QInputDevice;

55−class QInputDeviceInfoPrivate;

56+class QInputDeviceManager;

57+

56−class QInputDeviceInfo : public QObject

58+class Q_SYSTEMINFO_EXPORT QInputDevice : public QObject

57{

59{

58 Q_OBJECT

60 Q_OBJECT

59− Q_PROPERTY(int deviceCount READ deviceCount)

61+ Q_ENUMS(InputType)

62+ Q_FLAGS(InputType InputTypeFlags)

63+ friend class QInputDeviceManagerPrivate;

64+

60public:

65public:

62 enum InputType {

67 enum InputType {

@@ -69,67 +74,19 @@ public:

69 Switch = 32

74 Switch = 32

70 };

75 };

71 Q_ENUMS(InputType)

76 Q_ENUMS(InputType)

72− Q_FLAGS(InputTypes)

73− Q_DECLARE_FLAGS(InputTypes, InputType)

77+ Q_DECLARE_FLAGS(InputTypeFlags, InputType)

74−

75− explicit QInputDeviceInfo(QObject *parent = 0);

76−

77− Q_INVOKABLE QVector <QInputDevice *> deviceList();

78−

79− Q_INVOKABLE QMap <QString, QInputDevice *> deviceMap();

80− int deviceCount() { return deviceList().count(); }

81−Q_SIGNALS:

83− void deviceAdded(const QString & devicePath);

84− void deviceRemoved(const QString & devicePath);

85−

86− void ready();

87−

88−public Q_SLOTS:

89− void addedDevice(const QString & devicePath);

90−

91−private:

92− Q_DISABLE_COPY(QInputDeviceInfo)

93−#if !defined(QT_SIMULATOR)

94− QInputDeviceInfoPrivate *const d_ptr;

95− Q_DECLARE_PRIVATE(QInputDeviceInfo)

96−#endif

97−};

98−

99−class QInputDevice : public QObject

100−{

101− friend class QInputDeviceInfoPrivate;

102− Q_OBJECT

103− Q_ENUMS(InputType)

104− Q_FLAGS(InputTypes)

105− Q_PROPERTY(QString name READ name NOTIFY nameChanged)

106− Q_PROPERTY(QString devicePath READ devicePath NOTIFY devicePathChanged)

107− Q_PROPERTY(QList <int> buttons READ buttons NOTIFY buttonsChanged)

108− Q_PROPERTY(QList <int> switches READ switches NOTIFY switchesChanged)

109− Q_PROPERTY(QList <int> relativeAxis READ relativeAxis NOTIFY relativeAxisChanged)

110− Q_PROPERTY(QList <int> absoluteAxis READ absoluteAxis NOTIFY absoluteAxisChanged)

111− Q_PROPERTY(QInputDeviceInfo::InputTypes types READ types NOTIFY typesChanged)

112−

113−public:

114 explicit QInputDevice(QObject *parent = 0);

79 explicit QInputDevice(QObject *parent = 0);

115−

116 QString name() const;

80 QString name() const;

117 QString devicePath() const;

81 QString devicePath() const;

118 QList <int> buttons() const; //keys event code

82 QList <int> buttons() const; //keys event code

119 QList <int> switches() const;

83 QList <int> switches() const;

120 QList <int> relativeAxis() const;

84 QList <int> relativeAxis() const;

121 QList <int> absoluteAxis() const;

85 QList <int> absoluteAxis() const;

86+ QInputDevice::InputTypeFlags type() const;

122

123− QInputDeviceInfo::InputTypes types();

124−Q_SIGNALS:

125− void nameChanged();

126− void devicePathChanged();

127− void buttonsChanged();

128− void switchesChanged();

129− void relativeAxisChanged();

130− void absoluteAxisChanged();

131− void typesChanged();

132private:

88private:

89+

133 QInputDevicePrivate *d_ptr;

90 QInputDevicePrivate *d_ptr;

134 void setName(const QString &);

91 void setName(const QString &);

135 void setDevicePath(const QString &);

92 void setDevicePath(const QString &);

@@ -137,7 +94,51 @@ private:

137 void addSwitch(int);

94 void addSwitch(int);

138 void addRelativeAxis(int);

95 void addRelativeAxis(int);

139 void addAbsoluteAxis(int);

96 void addAbsoluteAxis(int);

140− void setTypes(QInputDeviceInfo::InputTypes);

97+ void setType(QInputDevice::InputTypeFlags flags);

98+

99+};

100+

101+Q_DECLARE_METATYPE(QInputDevice::InputType)

102+Q_DECLARE_METATYPE(QInputDevice::InputTypeFlags)

103+

104+class QInputDeviceManagerPrivate;

105+

106+class Q_SYSTEMINFO_EXPORT QInputDeviceManager : public QObject

107+{

108+ Q_OBJECT

109+ Q_PROPERTY(int deviceCount READ deviceCount NOTIFY deviceCountChanged)

110+ Q_PROPERTY(QInputDevice::InputType deviceFilter READ deviceFilter WRITE setDeviceFilter NOTIFY deviceFilterChanged)

111+public:

112+

113+ explicit QInputDeviceManager(QObject *parent = 0);

114+

115+ int deviceCount() const;

116+ int deviceCount(const QInputDevice::InputType filter) const;

117+

118+ void setDeviceFilter(QInputDevice::InputType filter);

119+ QInputDevice::InputType deviceFilter();

120+

121+ QMap <QString, QInputDevice *> deviceMap();

122+ Q_INVOKABLE QVector <QInputDevice *> deviceListOfType(QInputDevice::InputType filter);

123+

124+Q_SIGNALS:

125+

126+ void deviceAdded(const QString & devicePath);

127+ void deviceRemoved(const QString & devicePath);

128+

129+ void ready();

130+ void deviceCountChanged(int count);

131+ void deviceFilterChanged(const QInputDevice::InputType filter);

132+

133+public Q_SLOTS:

134+ void addedDevice(const QString & devicePath);

135+

136+private:

137+ Q_DISABLE_COPY(QInputDeviceManager)

138+#if !defined(QT_SIMULATOR)

139+ QInputDeviceManagerPrivate *const d_ptr;

140+ Q_DECLARE_PRIVATE(QInputDeviceManager)

141+#endif

141};

142};

142

143

143#endif // QINPUTINFO_H

144#endif // QINPUTINFO_H

qml/Components/UnityInputInfo/UnityInputInfo.qml+8−64

@@ -23,71 +23,15 @@ import Ubuntu.Components 1.2

24Item {

25 id: root

26− readonly property alias mice: priv.miceCount

26+ readonly property alias mice: miceModel.count

27− readonly property alias keyboards: priv.keyboardCount

27+ readonly property alias keyboards: keyboardModel.count

29− property alias inputInfo: inputInfo

29+ InputDeviceModel {

30−

30+ id: miceModel

31− QtObject {

31+ deviceFilter: InputInfo.Mouse

32− id: priv

33−

34− property var mice: []

35− property var keyboards: []

36−

37− property int miceCount: 0

38− property int keyboardCount: 0

39−

40− function addMouse(devicePath) {

41− mice.push(devicePath);

42− miceCount++;

43− }

44−

45− function addKeyboard(devicePath) {

46− keyboards.push(devicePath);

47− keyboardCount++;

48− }

49−

50− function removeDevice(devicePath) {

51− for (var i = 0; i < priv.mice.length; i++) {

52− if (priv.mice[i] == devicePath) {

53− priv.mice.splice(i, 1);

54− priv.miceCount--;

55− }

56− }

57− for (var i = 0; i < priv.keyboards.length; i++) {

58− if (priv.keyboards[i] == devicePath) {

59− priv.keyboards.splice(i, 1);

60− priv.keyboardCount--;

61− }

62− }

63− }

64 }

32 }

65−

33+ InputDeviceModel {

66− InputDeviceInfo {

34+ id: keyboardModel

67− id: inputInfo

35+ deviceFilter: InputInfo.Keyboard

68− objectName: "inputDeviceInfo"

69−

70− onNewDevice: {

71− var device = inputInfo.get(inputInfo.indexOf(devicePath));

72− if (device === null) {

73− return;

74− }

75−

76− var hasMouse = (device.types & InputInfo.Mouse) == InputInfo.Mouse

77− var hasTouchpad = (device.types & InputInfo.TouchPad) == InputInfo.TouchPad

78− var hasKeyboard = (device.types & InputInfo.Keyboard) == InputInfo.Keyboard

79−

80− if (hasMouse || hasTouchpad) {

81− priv.addMouse(devicePath);

82− } else if (hasKeyboard) {

83− // Only accepting keyboards that do not claim to be a mouse too

84− // This will be a bit buggy for real hybrid devices, but doesn't

85− // fall for Microsoft mice that claim to be Keyboards too.

86− priv.addKeyboard(devicePath)

87− }

88− }

89− onDeviceRemoved: {

90− priv.removeDevice(devicePath)

91− }

92 }

36 }

93}

37}