plugins/Unity/Indicators/flatmenuproxymodel.cpp · unity8

git.iko.soy/unity8

on cedbc3f help sign in

unity8/plugins/Unity/Indicators/flatmenuproxymodel.cpp

272 lines 7.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 * 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

59 connect(source,

60 SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),

61 SLOT(onModelAboutToBeReset()));

62 connect(source,

63 SIGNAL(rowsInserted(QModelIndex,int,int)),

64 SLOT(onModelReset()));

66 connect(source,

67 SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),

68 SLOT(onModelAboutToBeReset()));

69 connect(source,

70 SIGNAL(rowsRemoved(QModelIndex,int,int)),

71 SLOT(onModelReset()));

73 connect(source,

74 SIGNAL(modelAboutToBeReset()),

75 SLOT(onModelAboutToBeReset()));

76 connect(source,

77 SIGNAL(modelReset()),

78 SLOT(onModelReset()));

80 connect(source,

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

82 SIGNAL(statusChanged()));

84 // initiliaze rowCount

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

86 m_rowCount = recursiveRowCount(lastItem);

87 } else {

88 m_rowCount = 0;

89 }

91 Q_EMIT countChanged();

92}

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

95{

96 m_model->setBusName(busName);

97}

99QString FlatMenuProxyModel::busName() const

100{

101 return m_model->busName();

102}

103

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

105{

106 m_model->setObjectPath(busPath);

107}

108

109QString FlatMenuProxyModel::objectPath() const

110{

111 return m_model->objectPath();

112}

113

114int FlatMenuProxyModel::status() const

115{

116 return m_model->status();

117}

118

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

120{

121 return m_model->busType();

122}

123

124void FlatMenuProxyModel::setIntBusType(int type)

125{

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

127}

128

129void FlatMenuProxyModel::start()

130{

131 m_model->start();

132}

133

134void FlatMenuProxyModel::stop()

135{

136 m_model->stop();

137}

138

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

140{

141 if (!index.isValid()) {

142 return QModelIndex();

143 }

144

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

146 return result;

147}

148

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

150{

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

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

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

154 QModelIndex sourceIndex = QModelIndex();

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

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

157 }

158 return sourceIndex;

159 } else {

160 return QModelIndex();

161 }

162}

163

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

165{

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

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

168 int indexCount = recursiveRowCount(sourceIndex);

169

170 if (count == sectionRow) {

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

172 m_indexCache.insert(row, sectionKey);

173 return createIndex(row, 0);

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

175 count++;

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

177 }

178

179 count += indexCount + 1;

180 }

181 return QModelIndex();

182}

183

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

185{

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

187}

188

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

190{

191 return QModelIndex();

192}

193

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

195{

196 return 1;

197}

198

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

200{

201 return m_rowCount;

202}

203

204int FlatMenuProxyModel::count() const

205{

206 return rowCount(QModelIndex());

207}

208

209void FlatMenuProxyModel::onModelAboutToBeReset()

210{

211 beginResetModel();

212}

213

214void FlatMenuProxyModel::onModelReset()

215{

216 // initiliaze rowCount

217 m_rowCount = 0;

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

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

220 m_rowCount += recursiveRowCount(index) + 1;

221 }

222 m_indexCache.clear();

223 endResetModel();

224 Q_EMIT countChanged();

225}

226

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

228{

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

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

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

232 size += recursiveRowCount(currentIndex);

233 }

234

235 return size;

236}

237

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

239{

240 int offset = 0;

241

242 QModelIndex parent = index.parent();

243

244 // Check row 0 offset

245 while(parent.isValid()) {

246 offset += 1;

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

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

249 offset += recursiveRowCount(currentIndex) + 1;

250 }

251 parent = parent.parent();

252 }

253

254 // Check index.row() offset

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

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

257 offset += recursiveRowCount(currentIndex) + 1;

258 }

259

260 if (inclusive) {

261 // itself

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

263 offset += recursiveRowCount(currentIndex);

264 }

265

266 return offset;

267}

268

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

270{

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

272}