tests/plugins/WindowManager/UnityApplicationMocks.h · unity8

git.iko.soy/unity8

on cc5a4ec help sign in

unity8/tests/plugins/WindowManager/UnityApplicationMocks.h

228 lines 8.2 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 */

17#ifndef UNITYAPPLICATIONMOCKS_H

18#define UNITYAPPLICATIONMOCKS_H

20#include <unity/shell/application/ApplicationInfoInterface.h>

21#include <unity/shell/application/ApplicationManagerInterface.h>

22#include <unity/shell/application/MirSurfaceInterface.h>

23#include <unity/shell/application/SurfaceManagerInterface.h>

25// from tests/mocks

26#include <Unity/Application/MirSurfaceListModel.h>

28#include "wmpolicyinterface.h"

30using namespace unity::shell::application;

32class MirSurface : public MirSurfaceInterface

33{

34 Q_OBJECT

35public:

36 Mir::Type type() const override { return m_type; }

37 QString name() const override { return QString("foo"); }

38 QString persistentId() const override { return QString("a-b-c-my-id"); }

39 QString appId() const override { return QString(); }

40 QPoint position() const override { return QPoint(); }

41 QSize size() const override { return QSize(); }

42 void resize(int, int) override {}

43 void resize(const QSize &) override {}

44 Mir::State state() const override { return m_state; }

45 bool live() const override { return m_live; }

46 bool visible() const override { return true; }

47 Mir::OrientationAngle orientationAngle() const override { return Mir::Angle0; }

48 void setOrientationAngle(Mir::OrientationAngle) override {}

50 int minimumWidth() const override { return 0; }

51 int minimumHeight() const override { return 0; }

52 int maximumWidth() const override { return 0; }

53 int maximumHeight() const override { return 0; }

54 int widthIncrement() const override { return 0; }

55 int heightIncrement() const override { return 0; }

57 void setKeymap(const QString &) override {}

58 QString keymap() const override { return QString(); }

59 Mir::ShellChrome shellChrome() const override { return Mir::NormalChrome; }

60 bool focused() const override { return true; }

61 QRect inputBounds() const override { return QRect(); }

62 bool confinesMousePointer() const override { return false; }

63 bool allowClientResize() const override { return true; }

64 void setAllowClientResize(bool) override {}

65 QPoint requestedPosition() const override { return QPoint(); }

66 void setRequestedPosition(const QPoint &) override {}

67 MirSurfaceInterface* parentSurface() const override { return nullptr; }

68 unity::shell::application::MirSurfaceListInterface* childSurfaceList() const override { return nullptr; }

69 void close() override {}

70 void activate() override {}

72public Q_SLOTS:

73 void requestState(Mir::State value) override

74 {

75 if (m_state != value) {

76 m_state = value;

77 Q_EMIT stateChanged(m_state);

78 }

79 }

81public:

82 Mir::Type m_type { Mir::NormalType };

83 Mir::State m_state { Mir::RestoredState };

84 bool m_live { true };

85};

87class SurfaceManager : public SurfaceManagerInterface

88{

89 Q_OBJECT

91public:

92 void forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace>&,

93 const std::function<void(unity::shell::application::MirSurfaceInterface*)>&) override {}

94 void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface*,

95 const std::shared_ptr<miral::Workspace>&) override {}

96 void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace>&,

97 const std::shared_ptr<miral::Workspace>&) override {}

99 void raise(MirSurfaceInterface *) override {}

100 void activate(MirSurfaceInterface *) override {}

101};

102

103class Application : public ApplicationInfoInterface

104{

105 Q_OBJECT

106public:

107 Application(QString appId) : ApplicationInfoInterface(appId, nullptr), m_appId(std::move(appId)) {}

108

109 void close() override {}

110 QString appId() const override { return m_appId;}

111 QString name() const override { return "foo"; }

112 QString comment() const override { return "bar"; }

113 QUrl icon() const override { return QUrl(); }

114 State state() const override { return m_state; }

115 RequestedState requestedState() const override { return m_requestedState; }

116 void setRequestedState(RequestedState value) override

117 {

118 if (value != m_requestedState) {

119 m_requestedState = value;

120 Q_EMIT requestedStateChanged(value);

121 }

122 }

123 bool focused() const override { return false; }

124 QString splashTitle() const override { return QString(); }

125 QUrl splashImage() const override { return QUrl(); }

126 bool splashShowHeader() const override { return false; }

127 QColor splashColor() const override { return QColor(); }

128 QColor splashColorHeader() const override { return QColor(); }

129 QColor splashColorFooter() const override { return QColor(); }

130 Qt::ScreenOrientations supportedOrientations() const override { return Qt::LandscapeOrientation; }

131 bool rotatesWindowContents() const override { return false; }

132 bool isTouchApp() const override { return false; }

133 bool exemptFromLifecycle() const override { return false; }

134 void setExemptFromLifecycle(bool) override {}

135 QSize initialSurfaceSize() const override { return QSize(); }

136 void setInitialSurfaceSize(const QSize &) override {}

137 MirSurfaceListInterface* surfaceList() const override { return &m_surfaceList; }

138 MirSurfaceListInterface* promptSurfaceList() const override { return nullptr; }

139 int surfaceCount() const override { return 0; }

140

141 QString m_appId;

142 State m_state;

143 RequestedState m_requestedState;

144 mutable MirSurfaceListModel m_surfaceList;

145};

146

147class ApplicationManager : public ApplicationManagerInterface

148{

149 Q_OBJECT

150

151public:

152

153 int rowCount(const QModelIndex &) const override

154 {

155 return m_applications.count();

156 }

157

158 QVariant data(const QModelIndex &/*index*/, int /*role*/) const override

159 {

160 return QVariant();

161 }

162

163 QString focusedApplicationId() const override {return QString();}

164

165 ApplicationInfoInterface *get(int index) const override

166 {

167 return m_applications[index];

168 }

169

170 ApplicationInfoInterface *findApplication(const QString &appId) const override

171 {

172 Q_UNUSED(appId);

173 return nullptr;

174 }

175

176 ApplicationInfoInterface *findApplicationWithSurface(MirSurfaceInterface* surface) const override

177 {

178 for (int i = 0; i < m_applications.count(); ++i) {

179 if (m_applications[i]->m_surfaceList.contains(surface)) {

180 return m_applications[i];

181 }

182 }

183 return nullptr;

184 }

185

186 bool requestFocusApplication(const QString &appId) override

187 {

188 Q_UNUSED(appId);

189 return false;

190 }

191

192 ApplicationInfoInterface *startApplication(const QString &appId, const QStringList &/*arguments*/) override

193 {

194 Application *application = new Application(appId);

195 prepend(application);

196 return application;

197 }

198

199 bool stopApplication(const QString &) override { return true; }

200

201private:

202 void prepend(Application *application)

203 {

204 beginInsertRows(QModelIndex(), 0 /*first*/, 0 /*last*/);

205 m_applications.append(application);

206 endInsertRows();

207 }

208

209 QList<Application*> m_applications;

210};

211

212namespace miral {

213class Workspace {};

214}

215

216class WindowManagementPolicy : public WMPolicyInterface

217{

218public:

219 WindowManagementPolicy() {}

220

221 std::shared_ptr<miral::Workspace> createWorkspace() override { return std::make_shared<miral::Workspace>(); }

222

223 void releaseWorkspace(const std::shared_ptr<miral::Workspace>&) override {}

224

225 void setActiveWorkspace(const std::shared_ptr<miral::Workspace>&) override {}

226};

227

228#endif // UNITYAPPLICATIONMOCKS_H