plugins/Unity/Indicators/indicatorsmodel.cpp · unity8

git.iko.soy/unity8

on cedbc3f help sign in

unity8/plugins/Unity/Indicators/indicatorsmodel.cpp

321 lines 8.7 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 * Renato Araujo Oliveira Filho <renato@canonical.com>

18 */

20#include "indicatorsmodel.h"

21#include "indicatorsmanager.h"

22#include "indicator.h"

23#include "indicators.h"

24#include "paths.h"

26#include <QQmlContext>

27#include <QQmlEngine>

28#include <QDebug>

30/*!

31 \qmltype IndicatorsModel

32 \inherits QAbstractListModel

34 \brief The IndicatorsModel class defines the list model for indicators

36 \b {This component is under heavy development.}

38 This class expose the available indicators.

40 \code

41 IndicatorsModel {

42 id: menuModel

43 }

45 ListView {

46 id: view

47 model: menuModel

48 Component.onCompleted: menuModel.load()

49 }

50 \endcode

51*/

52IndicatorsModel::IndicatorsModel(QObject *parent)

53 : QAbstractListModel(parent)

54{

55 m_manager = new IndicatorsManager(this);

56 QObject::connect(m_manager, SIGNAL(indicatorLoaded(const QString&)), this, SLOT(onIndicatorLoaded(const QString&)));

57 QObject::connect(m_manager, SIGNAL(indicatorAboutToBeUnloaded(const QString&)), this, SLOT(onIndicatorAboutToBeUnloaded(const QString&)));

59 QObject::connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)), this, SIGNAL(countChanged()));

60 QObject::connect(this, SIGNAL(rowsRemoved(const QModelIndex &, int, int)), this, SIGNAL(countChanged()));

61 QObject::connect(this, SIGNAL(modelReset()), this, SIGNAL(countChanged()));

62}

64/*! \internal */

65IndicatorsModel::~IndicatorsModel()

66{

67 disconnect(m_manager, 0, 0, 0);

68 m_manager->deleteLater();

69}

71/*!

72 \qmlproperty IndicatorsModel::count

73 The number of data entries in the model.

75 \b Note: methods should only be called after the Component has completed.

76*/

77int IndicatorsModel::count() const

78{

79 return rowCount();

80}

82/*!

83 \qmlmethod IndicatorsModel::unload()

85 Load all indicators.

86*/

87void IndicatorsModel::load()

88{

89 m_indicators.clear();

90 m_manager->load();

91}

93/*!

94 \qmlmethod IndicatorsModel::unload()

96 Unload all indicators.

97*/

98void IndicatorsModel::unload()

99{

100 m_manager->unload();

101}

102

103/*! \internal */

104void IndicatorsModel::onIndicatorLoaded(const QString& indicator_name)

105{

106 Indicator::Ptr indicator = m_manager->indicator(indicator_name);

107 if (!indicator)

108 {

109 return;

110 }

111

112 if (m_indicators.indexOf(indicator) >= 0)

113 {

114 return;

115 }

116

117 // find the insert position

118 int pos = 0;

119 while (pos < count())

120 {

121 // keep going while the existing priority is less.

122 if (indicatorData(indicator, IndicatorsModelRole::Priority).toInt() < data(index(pos), IndicatorsModelRole::Priority).toInt())

123 break;

124 pos++;

125 }

126

127 QObject::connect(indicator.data(), SIGNAL(identifierChanged(const QString&)), this, SLOT(onIdentifierChanged()));

128 QObject::connect(indicator.data(), SIGNAL(indicatorPropertiesChanged(const QVariant&)), this, SLOT(onIndicatorPropertiesChanged()));

129

130 beginInsertRows(QModelIndex(), pos, pos);

131

132 m_indicators.insert(pos, indicator);

133 endInsertRows();

134}

135

136/*! \internal */

137void IndicatorsModel::onIndicatorAboutToBeUnloaded(const QString& indicator_name)

138{

139 Indicator::Ptr indicator = m_manager->indicator(indicator_name);

140 if (!indicator)

141 {

142 return;

143 }

144

145 int i = 0;

146 QMutableListIterator<Indicator::Ptr> iter(m_indicators);

147 while(iter.hasNext())

148 {

149 if (indicator == iter.next())

150 {

151 beginRemoveRows(QModelIndex(), i, i);

152 iter.remove();

153 endRemoveRows();

154 break;

155 }

156 i++;

157 }

158

159}

160

161/*! \internal */

162void IndicatorsModel::onIdentifierChanged()

163{

164 notifyDataChanged(QObject::sender(), IndicatorsModelRole::Identifier);

165}

166

167/*! \internal */

168void IndicatorsModel::onIndicatorPropertiesChanged()

169{

170 notifyDataChanged(QObject::sender(), IndicatorsModelRole::IndicatorProperties);

171}

172

173/*! \internal */

174void IndicatorsModel::notifyDataChanged(QObject *sender, int role)

175{

176 Indicator* indicator = qobject_cast<Indicator*>(sender);

177 if (!indicator)

178 {

179 return;

180 }

181

182 int index = 0;

183 QMutableListIterator<Indicator::Ptr> iter(m_indicators);

184 while(iter.hasNext())

185 {

186 if (indicator == iter.next())

187 {

188 QModelIndex changedIndex = this->index(index);

189 dataChanged(changedIndex, changedIndex, QVector<int>() << role);

190 break;

191 }

192 index++;

193 }

194}

195

196/*! \internal */

197QHash<int, QByteArray> IndicatorsModel::roleNames() const

198{

199 static QHash<int, QByteArray> roles;

200 if (roles.isEmpty())

201 {

202 roles[IndicatorsModelRole::Identifier] = "identifier";

203 roles[IndicatorsModelRole::Priority] = "priority";

204 roles[IndicatorsModelRole::Title] = "title";

205 roles[IndicatorsModelRole::Description] = "description";

206 roles[IndicatorsModelRole::WidgetSource] = "widgetSource";

207 roles[IndicatorsModelRole::PageSource] = "pageSource";

208 roles[IndicatorsModelRole::IndicatorProperties] = "indicatorProperties";

209 roles[IndicatorsModelRole::IsValid] = "isValid";

210 }

211 return roles;

212}

213

214/*! \internal */

215int IndicatorsModel::columnCount(const QModelIndex &) const

216{

217 return 1;

218}

219

220/*! \internal */

221QVariant IndicatorsModel::defaultData(Indicator::Ptr indicator, int role)

222{

223 switch (role)

224 {

225 case IndicatorsModelRole::Priority:

226 return 0;

227 case IndicatorsModelRole::Title:

228 return indicator ? indicator->identifier() : "Unknown";

229 case IndicatorsModelRole::Description:

230 return "";

231 case IndicatorsModelRole::WidgetSource:

232 return shellAppDirectory()+"/Panel/Indicators/DefaultIndicatorWidget.qml";

233 case IndicatorsModelRole::PageSource:

234 return shellAppDirectory()+"/Panel/Indicators/DefaultIndicatorPage.qml";

235 }

236 return QVariant();

237}

238

239Q_INVOKABLE QVariant IndicatorsModel::data(int row, int role) const

240{

241 return data(index(row, 0), role);

242}

243

244/*! \internal */

245QVariant IndicatorsModel::data(const QModelIndex &index, int role) const

246{

247 if (!index.isValid() || index.row() >= m_indicators.size())

248 return QVariant();

249

250 Indicator::Ptr indicator = m_indicators[index.row()];

251

252 switch (role)

253 {

254 case IndicatorsModelRole::Identifier:

255 if (indicator)

256 {

257 return QVariant(indicator->identifier());

258 }

259 break;

260 case IndicatorsModelRole::IndicatorProperties:

261 if (indicator)

262 {

263 return QVariant(indicator->indicatorProperties());

264 }

265 break;

266 case IndicatorsModelRole::IsValid:

267 return (indicator ? true : false);

268 case IndicatorsModelRole::Priority:

269 case IndicatorsModelRole::Title:

270 case IndicatorsModelRole::Description:

271 case IndicatorsModelRole::WidgetSource:

272 case IndicatorsModelRole::PageSource:

273 return indicatorData(indicator, role);

274 default:

275 break;

276 }

277 return QVariant();

278}

279

280QVariant IndicatorsModel::indicatorData(const Indicator::Ptr& indicator, int role) const

281{

282 if (indicator && m_parsed_indicator_data.contains(indicator->identifier()))

283 {

284 QVariantMap data = m_parsed_indicator_data[indicator->identifier()];

285 return data.value(roleNames()[role], QVariant());

286 }

287 return defaultData(indicator, role);

288}

289

290/*! \internal */

291QModelIndex IndicatorsModel::parent(const QModelIndex&) const

292{

293 return QModelIndex();

294}

295

296/*! \internal */

297int IndicatorsModel::rowCount(const QModelIndex&) const

298{

299 return m_indicators.count();

300}

301

302void IndicatorsModel::setIndicatorData(const QVariant& data)

303{

304 m_indicator_data = data;

305

306 m_parsed_indicator_data.clear();

307 QMap<QString, QVariant> map = data.toMap();

308 QMapIterator<QString, QVariant> iter(map);

309 while(iter.hasNext())

310 {

311 iter.next();

312 m_parsed_indicator_data[iter.key()] = iter.value().toMap();

313 }

314

315 Q_EMIT indicatorDataChanged(m_indicator_data);

316}

317

318QVariant IndicatorsModel::indicatorData() const

319{

320 return m_indicator_data;

321}