plugins/Unity/Launcher/launchermodel.cpp · unity8

git.iko.soy/unity8

on 12a88ee help sign in

unity8/plugins/Unity/Launcher/launchermodel.cpp

272 lines 8.1 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 "launchermodel.h"

21#include "launcheritem.h"

22#include "backend/launcherbackend.h"

24LauncherModel::LauncherModel(QObject *parent):

25 LauncherModelInterface(parent),

26 m_backend(new LauncherBackend(true, this))

27{

28 connect(m_backend, SIGNAL(countChanged(QString,int)), SLOT(countChanged(QString,int)));

29 connect(m_backend, SIGNAL(progressChanged(QString,int)), SLOT(progressChanged(QString,int)));

31 Q_FOREACH (const QString &entry, m_backend->storedApplications()) {

32 LauncherItem *item = new LauncherItem(entry,

33 m_backend->desktopFile(entry),

34 m_backend->displayName(entry),

35 m_backend->icon(entry),

36 this);

37 if (m_backend->isPinned(entry)) {

38 item->setPinned(true);

39 } else {

40 item->setRecent(true);

41 }

42 m_list.append(item);

43 }

44}

46LauncherModel::~LauncherModel()

47{

48 while (!m_list.empty()) {

49 m_list.takeFirst()->deleteLater();

50 }

51}

53int LauncherModel::rowCount(const QModelIndex &parent) const

54{

55 Q_UNUSED(parent)

56 return m_list.count();

57}

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

60{

61 LauncherItem *item = m_list.at(index.row());

62 switch(role) {

63 case RoleAppId:

64 return item->desktopFile();

65 case RoleDesktopFile:

66 return item->desktopFile();

67 case RoleName:

68 return item->name();

69 case RoleIcon:

70 return item->icon();

71 case RolePinned:

72 return item->pinned();

73 case RoleCount:

74 return item->count();

75 case RoleProgress:

76 return item->progress();

77 }

79 return QVariant();

80}

82unity::shell::launcher::LauncherItemInterface *LauncherModel::get(int index) const

83{

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

85 return 0;

86 }

87 return m_list.at(index);

88}

90void LauncherModel::move(int oldIndex, int newIndex)

91{

92 // Make sure its not moved outside the lists

93 if (newIndex < 0) {

94 newIndex = 0;

95 }

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

97 newIndex = m_list.count()-1;

98 }

100 // Nothing to do?

101 if (oldIndex == newIndex) {

102 return;

103 }

104

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

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

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

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

109

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

111 m_list.move(oldIndex, newIndex);

112 endMoveRows();

113

114 storeAppList();

115

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

117}

118

119void LauncherModel::pin(const QString &appId, int index)

120{

121 int currentIndex = findApplication(appId);

122

123 if (currentIndex >= 0) {

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

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

126 m_backend->setPinned(appId, true);

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

128 Q_EMIT dataChanged(modelIndex, modelIndex);

129 } else {

130 move(currentIndex, index);

131 }

132 } else {

133 if (index == -1) {

134 index = m_list.count();

135 }

136 beginInsertRows(QModelIndex(), index, index);

137 LauncherItem *item = new LauncherItem(appId,

138 m_backend->desktopFile(appId),

139 m_backend->displayName(appId),

140 m_backend->icon(appId));

141 item->setPinned(true);

142 m_backend->setPinned(appId, true);

143 m_list.insert(index, item);

144 endInsertRows();

145 }

146}

147

148void LauncherModel::requestRemove(const QString &appId)

149{

150 int index = findApplication(appId);

151 if (index < 0) {

152 return;

153 }

154

155 beginRemoveRows(QModelIndex(), index, index);

156 m_list.takeAt(index)->deleteLater();

157 endRemoveRows();

158

159 storeAppList();

160}

161

162void LauncherModel::quickListActionInvoked(const QString &appId, int actionIndex)

163{

164 int index = findApplication(appId);

165 if (index < 0) {

166 return;

167 }

168

169 LauncherItem *item = m_list.at(index);

170 QuickListModel *model = qobject_cast<QuickListModel*>(item->quickList());

171 if (model) {

172 QString actionId = model->get(actionIndex).actionId();

173

174 // Check if this is one of the launcher actions we handle ourselves

175 if (actionId == "pin_item") {

176 if (item->pinned()) {

177 requestRemove(appId);

178 } else {

179 pin(appId);

180 }

181

182 // Nope, we don't know this action, let the backend forward it to the application

183 } else {

184 m_backend->triggerQuickListAction(appId, actionId);

185 }

186 }

187}

188

189void LauncherModel::setUser(const QString &username)

190{

191 m_backend->setUser(username);

192}

193

194void LauncherModel::applicationFocused(const QString &appId)

195{

196 int index = findApplication(appId);

197

198 if (index >= 0) {

199 // TODO: Mark application as focued

200 } else {

201 // Add app to recent apps

202 QString desktopFile = m_backend->desktopFile(appId);

203 QString appName = m_backend->displayName(appId);

204 QString icon = m_backend->icon(appId);

205

206 LauncherItem *item = new LauncherItem(appId, desktopFile, appName, icon);

207 item->setRecent(true);

208 beginInsertRows(QModelIndex(), m_list.count(), m_list.count());

209 m_list.append(item);

210 endInsertRows();

211

212 // Clean up old recent apps

213 QList<int> recentAppIndices;

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

215 if (m_list.at(i)->recent()) {

216 recentAppIndices << i;

217 }

218 }

219 int run = 0;

220 while (recentAppIndices.count() > 5) {

221 beginRemoveRows(QModelIndex(), recentAppIndices.first() - run, recentAppIndices.first() - run);

222 m_list.takeAt(recentAppIndices.first() - run)->deleteLater();

223 endRemoveRows();

224 recentAppIndices.takeFirst();

225 ++run;

226 }

227 storeAppList();

228 }

229}

230

231void LauncherModel::storeAppList()

232{

233 QStringList appIds;

234 Q_FOREACH(LauncherItem *item, m_list) {

235 if (item->pinned() || item->recent()) {

236 appIds << item->appId();

237 }

238 }

239 m_backend->setStoredApplications(appIds);

240}

241

242int LauncherModel::findApplication(const QString &appId)

243{

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

245 LauncherItem *item = m_list.at(i);

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

247 return i;

248 }

249 }

250 return -1;

251}

252

253void LauncherModel::progressChanged(const QString &appId, int progress)

254{

255 int idx = findApplication(appId);

256 if (idx >= 0) {

257 LauncherItem *item = m_list.at(idx);

258 item->setProgress(progress);

259 Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleProgress);

260 }

261}

262

263

264void LauncherModel::countChanged(const QString &appId, int count)

265{

266 int idx = findApplication(appId);

267 if (idx >= 0) {

268 LauncherItem *item = m_list.at(idx);

269 item->setCount(count);

270 Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleCount);

271 }

272}