plugins/Unity/IndicatorsLegacy/flatmenuproxymodel.cpp · unity8

git.iko.soy/unity8

on 3dfabbd help sign in

unity8/plugins/Unity/IndicatorsLegacy/flatmenuproxymodel.cpp

275 lines 7.6 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 */

20extern "C" {

21#include <gio/gio.h>

22}

24#include "flatmenuproxymodel.h"

25#include <QString>

26#include <QStringList>

28FlatMenuProxyModel::FlatMenuProxyModel(QAbstractItemModel *source)

29 : QAbstractProxyModel(source),

30 m_rowCount(0)

31{

32 m_model = new QDBusMenuModel;

33 setSourceModel(m_model);

34}

36/*! \internal */

37FlatMenuProxyModel::~FlatMenuProxyModel()

38{

39 delete m_model;

40}

42void FlatMenuProxyModel::setSourceModel(QAbstractItemModel *source)

43{

44 if (sourceModel()) {

45 QAbstractItemModel *oldSource = sourceModel();

46 if (oldSource == source) {

47 return;

48 }

50 oldSource->disconnect(this);

51 }

53 QAbstractProxyModel::setSourceModel(source);

55 if (source) {

57 // FIXME - not working correctly with dynamic inserts/removes

58 // FIXME 2 - We're using Queud connections as a workaround to QTBUG-32859

59 // The signals from qmenumodel are coming straight off the glib event loop,

60 // which is not supported and has the effect of listview delegates not to be deleted.

62 connect(source,

63 SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),

64 SLOT(onModelAboutToBeReset()), Qt::QueuedConnection);

65 connect(source,

66 SIGNAL(rowsInserted(QModelIndex,int,int)),

67 SLOT(onModelReset()), Qt::QueuedConnection);

69 connect(source,

70 SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),

71 SLOT(onModelAboutToBeReset()), Qt::QueuedConnection);

72 connect(source,

73 SIGNAL(rowsRemoved(QModelIndex,int,int)),

74 SLOT(onModelReset()), Qt::QueuedConnection);

76 connect(source,

77 SIGNAL(modelAboutToBeReset()),

78 SLOT(onModelAboutToBeReset()), Qt::QueuedConnection);

79 connect(source,

80 SIGNAL(modelReset()),

81 SLOT(onModelReset()), Qt::QueuedConnection);

83 connect(source,

84 SIGNAL(statusChanged(DBusEnums::ConnectionStatus)),

85 SIGNAL(statusChanged()), Qt::QueuedConnection);

87 // initiliaze rowCount

88 QModelIndex lastItem = source->index(source->rowCount() - 1, 0);

89 m_rowCount = recursiveRowCount(lastItem);

90 } else {

91 m_rowCount = 0;

92 }

94 Q_EMIT countChanged();

95}

97void FlatMenuProxyModel::setBusName(const QString &busName)

98{

99 m_model->setBusName(busName);

100}

101

102QString FlatMenuProxyModel::busName() const

103{

104 return m_model->busName();

105}

106

107void FlatMenuProxyModel::setObjectPath(const QString &busPath)

108{

109 m_model->setObjectPath(busPath);

110}

111

112QString FlatMenuProxyModel::objectPath() const

113{

114 return m_model->objectPath();

115}

116

117int FlatMenuProxyModel::status() const

118{

119 return m_model->status();

120}

121

122DBusEnums::BusType FlatMenuProxyModel::busType() const

123{

124 return m_model->busType();

125}

126

127void FlatMenuProxyModel::setIntBusType(int type)

128{

129 m_model->setBusType((DBusEnums::BusType) type);

130}

131

132void FlatMenuProxyModel::start()

133{

134 m_model->start();

135}

136

137void FlatMenuProxyModel::stop()

138{

139 m_model->stop();

140}

141

142QModelIndex FlatMenuProxyModel::mapFromSource(const QModelIndex &index) const

143{

144 if (!index.isValid()) {

145 return QModelIndex();

146 }

147

148 QModelIndex result = createIndex(rowOffsetOf(index, index.row()), 0);

149 return result;

150}

151

152QModelIndex FlatMenuProxyModel::mapToSource(const QModelIndex &index) const

153{

154 if (sourceModel() && m_indexCache.contains(index.row())) {

155 QString key = m_indexCache.value(index.row());

156 QStringList sections = key.split('.', QString::SkipEmptyParts);

157 QModelIndex sourceIndex = QModelIndex();

158 for(int i=0; i < sections.size(); i++) {

159 sourceIndex = sourceModel()->index(sections.at(i).toInt(), 9, sourceIndex);

160 }

161 return sourceIndex;

162 } else {

163 return QModelIndex();

164 }

165}

166

167QModelIndex FlatMenuProxyModel::index(int row, int sectionRow, const QModelIndex &parent, const QString &key) const

168{

169 for (int i = 0, count = 0; i < sourceModel()->rowCount(parent); i++) {

170 QModelIndex sourceIndex = sourceModel()->index(i, 0, parent);

171 int indexCount = recursiveRowCount(sourceIndex);

172

173 if (count == sectionRow) {

174 QString sectionKey = key + "." + QString::number(i);

175 m_indexCache.insert(row, sectionKey);

176 return createIndex(row, 0);

177 } else if ((count + indexCount) >= sectionRow) {

178 count++;

179 return index(row, sectionRow - count, sourceIndex, key + "." + QString::number(i));

180 }

181

182 count += indexCount + 1;

183 }

184 return QModelIndex();

185}

186

187QModelIndex FlatMenuProxyModel::index(int row, int, const QModelIndex &) const

188{

189 return index(row, row, QModelIndex(), "");

190}

191

192QModelIndex FlatMenuProxyModel::parent(const QModelIndex &) const

193{

194 return QModelIndex();

195}

196

197int FlatMenuProxyModel::columnCount(const QModelIndex &) const

198{

199 return 1;

200}

201

202int FlatMenuProxyModel::rowCount(const QModelIndex &) const

203{

204 return m_rowCount;

205}

206

207int FlatMenuProxyModel::count() const

208{

209 return rowCount(QModelIndex());

210}

211

212void FlatMenuProxyModel::onModelAboutToBeReset()

213{

214 beginResetModel();

215}

216

217void FlatMenuProxyModel::onModelReset()

218{

219 // initiliaze rowCount

220 m_rowCount = 0;

221 for (int i = 0, iMax = sourceModel()->rowCount(); i < iMax; i++) {

222 QModelIndex index = sourceModel()->index(i, 0);

223 m_rowCount += recursiveRowCount(index) + 1;

224 }

225 m_indexCache.clear();

226 endResetModel();

227 Q_EMIT countChanged();

228}

229

230int FlatMenuProxyModel::recursiveRowCount(const QModelIndex &index) const

231{

232 int size = sourceModel()->rowCount(index);

233 for (int i=0, iMax=size; i < iMax; i++) {

234 QModelIndex currentIndex = sourceModel()->index(i, 0, index);

235 size += recursiveRowCount(currentIndex);

236 }

237

238 return size;

239}

240

241int FlatMenuProxyModel::rowOffsetOf(const QModelIndex &index, int row, bool inclusive) const

242{

243 int offset = 0;

244

245 QModelIndex parent = index.parent();

246

247 // Check row 0 offset

248 while(parent.isValid()) {

249 offset += 1;

250 for (int i = 0; i < parent.row(); i++) {

251 QModelIndex currentIndex = sourceModel()->index(i, 0, parent);

252 offset += recursiveRowCount(currentIndex) + 1;

253 }

254 parent = parent.parent();

255 }

256

257 // Check index.row() offset

258 for(int i = 0; i < row; i++) {

259 QModelIndex currentIndex = sourceModel()->index(i, 0, index.parent());

260 offset += recursiveRowCount(currentIndex) + 1;

261 }

262

263 if (inclusive) {

264 // itself

265 QModelIndex currentIndex = sourceModel()->index(row, 0, index.parent());

266 offset += recursiveRowCount(currentIndex);

267 }

268

269 return offset;

270}

271

272QVariant FlatMenuProxyModel::data(int row, int role) const

273{

274 return QAbstractProxyModel::data(index(row, 0), role);

275}