tests/mocks/QMenuModel/unitymenumodel.cpp · unity8

git.iko.soy/unity8

on fe71e21 help sign in

unity8/tests/mocks/QMenuModel/unitymenumodel.cpp

286 lines 6.9 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 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 General Public License for more details.

12 *

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

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

15 *

16 * Authors: Nick Dedekind <nick.dedekind@canonical.com>

17 */

19#include "unitymenumodel.h"

21enum MenuRoles {

22 LabelRole = Qt::DisplayRole + 1,

23 SensitiveRole,

24 IsSeparatorRole,

25 IconRole,

26 TypeRole,

27 ExtendedAttributesRole,

28 ActionRole,

29 ActionStateRole,

30 IsCheckRole,

31 IsRadioRole,

32 IsToggledRole,

33 ShortcutRole,

34 HasSubmenuRole

35};

37UnityMenuModel::UnityMenuModel(QObject *parent)

38: QAbstractListModel(parent)

39{

40}

42UnityMenuModel::~UnityMenuModel()

43{

44}

46QVariant UnityMenuModel::modelData() const

47{

48 return m_modelData;

49}

51void UnityMenuModel::setModelData(const QVariant& data)

52{

53 beginResetModel();

55 m_modelData = data.toList();

56 Q_EMIT modelDataChanged();

58 endResetModel();

59}

61void UnityMenuModel::insertRow(int row, const QVariant& data)

62{

63 row = qMin(row, rowCount());

65 beginInsertRows(QModelIndex(), row, row);

67 m_modelData.insert(row, data);

69 endInsertRows();

70}

72void UnityMenuModel::appendRow(const QVariant& data)

73{

74 insertRow(rowCount(), data);

75}

77void UnityMenuModel::removeRow(int row)

78{

79 if (row < 0 || rowCount() <= row) {

80 return;

81 }

83 beginRemoveRows(QModelIndex(), row, row);

85 m_modelData.removeAt(row);

87 endRemoveRows();

88}

90QByteArray UnityMenuModel::busName() const

91{

92 return m_busName;

93}

95void UnityMenuModel::setBusName(const QByteArray &busName)

96{

97 this->m_busName = busName;

98}

100QVariantMap UnityMenuModel::actions() const

101{

102 return m_actions;

103}

104

105void UnityMenuModel::setActions(const QVariantMap &actions)

106{

107 this->m_actions = actions;

108}

109

110QByteArray UnityMenuModel::menuObjectPath() const

111{

112 return m_menuObjectPath;

113}

114

115void UnityMenuModel::setMenuObjectPath(const QByteArray &path)

116{

117 this->m_menuObjectPath = path;

118}

119

120ActionStateParser* UnityMenuModel::actionStateParser() const

121{

122 return nullptr;

123}

124

125void UnityMenuModel::setActionStateParser(ActionStateParser*)

126{

127}

128

129QString UnityMenuModel::nameOwner() const

130{

131 return QString("");

132}

133

134int UnityMenuModel::rowCount(const QModelIndex&) const

135{

136 return m_modelData.count();

137}

138

139int UnityMenuModel::columnCount(const QModelIndex&) const

140{

141 return 1;

142}

143

144QVariant UnityMenuModel::data(const QModelIndex &index, int role) const

145{

146 QVariantMap v = rowData(index.row());

147 QString roleName = roleNames()[role];

148

149 if (v.contains(roleName)) return v[roleName];

150

151 // defaults

152 switch (role) {

153 case LabelRole: return QString();

154 case SensitiveRole: return true;

155 case IsSeparatorRole: return false;

156 case IconRole: return QString();

157 case TypeRole: return QString();

158 case ExtendedAttributesRole: return QVariantMap();

159 case ActionRole: return QString();

160 case ActionStateRole: return QVariant();

161 case IsCheckRole: return false;

162 case IsRadioRole: return false;

163 case IsToggledRole: return false;

164 case ShortcutRole: return QString();

165 case HasSubmenuRole: return subMenuData(index.row()).isValid();

166 default: break;

167 }

168 return QVariant();

169}

170

171QVariantMap UnityMenuModel::rowData(int row) const

172{

173 if (m_modelData.count() <= row) {

174 return QVariantMap();

175 }

176 QVariantMap vRow = m_modelData.value(row, QVariantMap()).toMap();

177 return vRow["rowData"].toMap();

178}

179

180QVariant UnityMenuModel::subMenuData(int row) const

181{

182 QVariantMap v = m_modelData.value(row, QVariantMap()).toMap();

183 return v.value("submenu", QVariant());

184}

185

186QModelIndex UnityMenuModel::index(int row, int column, const QModelIndex&) const

187{

188 return createIndex(row, column);

189}

190

191QModelIndex UnityMenuModel::parent(const QModelIndex &) const

192{

193 return QModelIndex();

194}

195

196QHash<int, QByteArray> UnityMenuModel::roleNames() const

197{

198 QHash<int, QByteArray> names;

199

200 names[LabelRole] = "label";

201 names[SensitiveRole] = "sensitive";

202 names[IsSeparatorRole] = "isSeparator";

203 names[IconRole] = "icon";

204 names[TypeRole] = "type";

205 names[ExtendedAttributesRole] = "ext";

206 names[ActionRole] = "action";

207 names[ActionStateRole] = "actionState";

208 names[IsCheckRole] = "isCheck";

209 names[IsRadioRole] = "isRadio";

210 names[IsToggledRole] = "isToggled";

211 names[ShortcutRole] = "shortcut";

212 names[HasSubmenuRole] = "hasSubmenu";

213

214 return names;

215}

216

217QObject * UnityMenuModel::submenu(int position, QQmlComponent*)

218{

219 if (position < 0 || m_modelData.count() < position) {

220 return nullptr;

221 }

222

223 while (submenus.count() <= position) {

224 submenus.append(nullptr);

225 }

226

227 QVariant submenuData = subMenuData(position);

228 if (submenuData.type() == (int)QMetaType::QVariantList) {

229 UnityMenuModel*& model = submenus[position];

230 if (!model) {

231 model = new UnityMenuModel(this);

232 connect(model, &UnityMenuModel::activated, this, &UnityMenuModel::activated);

233 }

234 if (model->modelData() != submenuData) {

235 model->setModelData(submenuData);

236 }

237 return model;

238 }

239

240 return nullptr;

241}

242

243bool UnityMenuModel::loadExtendedAttributes(int, const QVariantMap &)

244{

245 return false;

246}

247

248QVariant UnityMenuModel::get(int row, const QByteArray &role)

249{

250 static QHash<QByteArray, int> roles;

251 if (roles.isEmpty()) {

252 const QHash<int, QByteArray> names = roleNames();

253 for(auto it = names.begin(); it != names.end(); ++it)

254 roles.insert(it.value(), it.key());

255 }

256

257 return data(index(row, 0), roles[role]);

258}

259

260void UnityMenuModel::activate(int row, const QVariant&)

261{

262 QVariantMap vModelData = m_modelData.value(row, QVariantMap()).toMap();

263 QVariantMap rd = vModelData["rowData"].toMap();

264

265 bool isCheckable = rd[roleNames()[IsCheckRole]].toBool() || rd[roleNames()[IsRadioRole]].toBool();

266 if (isCheckable) {

267 rd[roleNames()[IsToggledRole]] = !rd[roleNames()[IsToggledRole]].toBool();

268 vModelData["rowData"] = rd;

269 m_modelData[row] = vModelData;

270

271 dataChanged(index(row, 0), index(row, 0), QVector<int>() << IsToggledRole);

272 }

273 Q_EMIT activated(rd[roleNames()[ActionRole]].toString());

274}

275

276void UnityMenuModel::changeState(int, const QVariant&)

277{

278}

279

280void UnityMenuModel::registerAction(UnityMenuAction*)

281{

282}

283

284void UnityMenuModel::unregisterAction(UnityMenuAction*)

285{

286}