tests/mocks/Unity/Launcher/MockLauncherModel.cpp · unity8

git.iko.soy/unity8

on f7134c6 help sign in

unity8/tests/mocks/Unity/Launcher/MockLauncherModel.cpp

293 lines 9.4 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU Lesser General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU Lesser General Public License for more details.

12 *

13 * You should have received a copy of the GNU Lesser General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 *

16 * Authors:

17 * Michael Zanetti <michael.zanetti@canonical.com>

18 */

20#include "MockLauncherModel.h"

21#include "MockLauncherItem.h"

23MockLauncherModel::MockLauncherModel(QObject* parent): LauncherModelInterface(parent)

24{

25 MockLauncherItem *item = new MockLauncherItem("dialer-app", "/usr/share/applications/dialer-app.desktop", "Dialer", "dialer-app", this);

26 item->setProgress(0);

27 item->setPinned(true);

28 item->setRunning(true);

29 item->setFocused(true);

30 m_list.append(item);

31 item = new MockLauncherItem("camera-app", "/usr/share/applications/camera-app.desktop", "Camera", "camera", this);

32 item->setProgress(10);

33 item->setPinned(true);

34 m_list.append(item);

35 item = new MockLauncherItem("camera-app2", "/usr/share/applications/camera-app2.desktop", "Camera2", "camera", this);

36 item->setPinned(true);

37 m_list.append(item);

38 item = new MockLauncherItem("gallery-app", "/usr/share/applications/gallery-app.desktop", "Gallery", "gallery", this);

39 item->setProgress(50);

40 item->setCountVisible(true);

41 item->setRunning(true);

42 item->setAlerting(false);

43 m_list.append(item);

44 item = new MockLauncherItem("music-app", "/usr/share/applications/music-app.desktop", "Music", "soundcloud", this);

45 m_list.append(item);

46 item = new MockLauncherItem("facebook-webapp", "/usr/share/applications/facebook-webapp.desktop", "Facebook", "facebook", this);

47 item->setProgress(150);

48 m_list.append(item);

49 item = new MockLauncherItem("webbrowser-app", "/usr/share/applications/webbrowser-app.desktop", "Browser", "browser", this);

50 item->setCount(1);

51 item->setCountVisible(true);

52 item->setRunning(true);

53 item->setAlerting(false);

54 m_list.append(item);

55 item = new MockLauncherItem("twitter-webapp", "/usr/share/applications/twitter-webapp.desktop", "Twitter", "twitter", this);

56 item->setCount(12);

57 item->setCountVisible(true);

58 item->setAlerting(false);

59 item->setPinned(true);

60 m_list.append(item);

61 item = new MockLauncherItem("gmail-webapp", "/usr/share/applications/gmail-webapp.desktop", "GMail", "gmail", this);

62 item->setCount(123);

63 item->setCountVisible(true);

64 item->setAlerting(false);

65 m_list.append(item);

66 item = new MockLauncherItem("ubuntu-weather-app", "/usr/share/applications/ubuntu-weather-app.desktop", "Weather", "weather", this);

67 item->setCount(1234567890);

68 item->setCountVisible(true);

69 item->setAlerting(false);

70 item->setPinned(true);

71 m_list.append(item);

72 item = new MockLauncherItem("notes-app", "/usr/share/applications/notes-app.desktop", "Notepad", "notepad", this);

73 item->setProgress(50);

74 item->setCount(5);

75 item->setCountVisible(true);

76 item->setAlerting(false);

77 item->setFocused(true);

78 item->setPinned(true);

79 m_list.append(item);

80 item = new MockLauncherItem("calendar-app", "/usr/share/applications/calendar-app.desktop","Calendar", "calendar", this);

81 item->setPinned(true);

82 m_list.append(item);

83 item = new MockLauncherItem("libreoffice", "/usr/share/applications/libreoffice.desktop","Libre Office", "libreoffice", this);

84 item->setPinned(true);

85 m_list.append(item);

86}

88MockLauncherModel::~MockLauncherModel()

89{

90}

92int MockLauncherModel::rowCount(const QModelIndex& parent) const

93{

94 Q_UNUSED(parent)

95 return m_list.count();

96}

98QVariant MockLauncherModel::data(const QModelIndex& index, int role) const

99{

100 LauncherItemInterface *item = m_list.at(index.row());

101 switch(role)

102 {

103 case RoleAppId:

104 return item->appId();

105 case RoleName:

106 return item->name();

107 case RoleIcon:

108 return item->icon();

109 case RolePinned:

110 return item->pinned();

111 case RoleRunning:

112 return item->running();

113 case RoleRecent:

114 return item->recent();

115 case RoleProgress:

116 return item->progress();

117 case RoleCount:

118 return item->count();

119 case RoleCountVisible:

120 return item->countVisible();

121 case RoleFocused:

122 return item->focused();

123 case RoleAlerting:

124 return item->alerting();

125 }

126

127 return QVariant();

128}

129

130unity::shell::launcher::LauncherItemInterface *MockLauncherModel::get(int index) const

131{

132 if (index < 0 || index >= m_list.count())

133 {

134 return 0;

135 }

136 return m_list.at(index);

137}

138

139void MockLauncherModel::setAlerting(const QString &appId, bool alerting) {

140 int index = findApp(appId);

141 if (index >= 0) {

142 QModelIndex modelIndex = this->index(index);

143 MockLauncherItem *item = m_list.at(index);

144 if (!item->focused()) {

145 item->setAlerting(alerting);

146 Q_EMIT dataChanged(modelIndex, modelIndex, QVector<int>() << RoleAlerting);

147 }

148 }

149}

150

151void MockLauncherModel::move(int oldIndex, int newIndex)

152{

153 // Make sure its not moved outside the lists

154 if (newIndex < 0) {

155 newIndex = 0;

156 }

157 if (newIndex >= m_list.count()) {

158 newIndex = m_list.count()-1;

159 }

160

161 // Nothing to do?

162 if (oldIndex == newIndex) {

163 return;

164 }

165

166 // QList's and QAbstractItemModel's move implementation differ when moving an item up the list :/

167 // While QList needs the index in the resulting list, beginMoveRows expects it to be in the current list

168 // adjust the model's index by +1 in case we're moving upwards

169 int newModelIndex = newIndex > oldIndex ? newIndex+1 : newIndex;

170

171 beginMoveRows(QModelIndex(), oldIndex, oldIndex, QModelIndex(), newModelIndex);

172 m_list.move(oldIndex, newIndex);

173 endMoveRows();

174

175 pin(m_list.at(newIndex)->appId());

176}

177

178void MockLauncherModel::pin(const QString &appId, int index)

179{

180 int currentIndex = findApp(appId);

181

182 if (currentIndex >= 0) {

183 if (index == -1 || index == currentIndex) {

184 m_list.at(currentIndex)->setPinned(true);

185 QModelIndex modelIndex = this->index(currentIndex);

186 Q_EMIT dataChanged(modelIndex, modelIndex);

187 } else {

188 move(currentIndex, index);

189 }

190 } else {

191 beginInsertRows(QModelIndex(), index, index);

192 m_list.insert(index, new MockLauncherItem(appId,

193 appId + ".desktop",

194 appId,

195 appId + ".png"));

196 m_list.at(index)->setPinned(true);

197 endInsertRows();

198 }

199}

200

201void MockLauncherModel::requestRemove(const QString &appId)

202{

203 int index = findApp(appId);

204 if (index >= 0) {

205 beginRemoveRows(QModelIndex(), index, 0);

206 MockLauncherItem * item = m_list.takeAt(index);

207 item->setRunning(false);

208 item->deleteLater();

209 endRemoveRows();

210 }

211}

212

213void MockLauncherModel::quickListActionInvoked(const QString &appId, int actionIndex)

214{

215 Q_EMIT quickListTriggered(appId, actionIndex);

216}

217

218int MockLauncherModel::findApp(const QString &appId)

219{

220 for (int i = 0; i < m_list.count(); ++i) {

221 MockLauncherItem *item = m_list.at(i);

222 if (item->appId() == appId) {

223 return i;

224 }

225 }

226 return -1;

227}

228

229void MockLauncherModel::setProgress(const QString &appId, int progress)

230{

231 int index = findApp(appId);

232 if (index >= 0) {

233 m_list.at(index)->setProgress(progress);

234 QModelIndex modelIndex = this->index(index);

235 Q_EMIT dataChanged(modelIndex, modelIndex, QVector<int>() << RoleProgress);

236 }

237}

238

239void MockLauncherModel::setUser(const QString &username)

240{

241 Q_UNUSED(username)

242 // TODO: implement this...

243}

244

245QString MockLauncherModel::getUrlForAppId(const QString &appId) const

246{

247 return "application:///" + appId + ".desktop";

248}

249

250void MockLauncherModel::setApplicationManager(unity::shell::application::ApplicationManagerInterface *applicationManager)

251{

252 Q_UNUSED(applicationManager)

253}

254

255bool MockLauncherModel::onlyPinned() const

256{

257 return false;

258}

259

260void MockLauncherModel::setOnlyPinned(bool onlyPinned)

261{

262 Q_UNUSED(onlyPinned)

263}

264

265void MockLauncherModel::emitHint()

266{

267 Q_EMIT hint();

268}

269

270void MockLauncherModel::setCount(const QString &appId, int count)

271{

272 int index = findApp(appId);

273 if (index >= 0) {

274 m_list.at(index)->setCount(count);

275 QModelIndex modelIndex = this->index(index);

276 Q_EMIT dataChanged(modelIndex, modelIndex);

277 }

278}

279

280void MockLauncherModel::setCountVisible(const QString &appId, bool countVisible)

281{

282 int index = findApp(appId);

283 if (index >= 0) {

284 m_list.at(index)->setCountVisible(countVisible);

285 QModelIndex modelIndex = this->index(index);

286 Q_EMIT dataChanged(modelIndex, modelIndex);

287 }

288}

289

290unity::shell::application::ApplicationManagerInterface *MockLauncherModel::applicationManager() const

291{

292 return nullptr;

293}