tests/plugins/WindowManager/UnityApplicationMocks.h · unity8

git.iko.soy/unity8

on master help sign in

unity8/tests/plugins/WindowManager/UnityApplicationMocks.h

210 lines 7.3 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>

28using namespace unity::shell::application;

30class MirSurface : public MirSurfaceInterface

31{

32 Q_OBJECT

33public:

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

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

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

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

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

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

40 void resize(int, int) override {}

41 void resize(const QSize &) override {}

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

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

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

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

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

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

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

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

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

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

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

55 void setKeymap(const QString &) override {}

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

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

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

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

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

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

62 void setAllowClientResize(bool) override {}

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

64 void setRequestedPosition(const QPoint &) override {}

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

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

67 void close() override {}

68 void activate() override {}

70public Q_SLOTS:

71 void requestState(Mir::State value) override

72 {

73 if (m_state != value) {

74 m_state = value;

75 Q_EMIT stateChanged(m_state);

76 }

77 }

79public:

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

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

82 bool m_live { true };

83};

85class SurfaceManager : public SurfaceManagerInterface

86{

87 Q_OBJECT

89public:

90 void raise(MirSurfaceInterface *) override {}

91 void activate(MirSurfaceInterface *) override {}

92};

94class Application : public ApplicationInfoInterface

95{

96 Q_OBJECT

97public:

98 Application(QString appId)

99 : ApplicationInfoInterface(appId, nullptr)

100 , m_appId(std::move(appId))

101 , m_state(Starting)

102 , m_requestedState(RequestedRunning)

103 {

104

105 }

106

107 void close() override {}

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

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

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

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

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

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

114 void setRequestedState(RequestedState value) override

115 {

116 if (value != m_requestedState) {

117 m_requestedState = value;

118 Q_EMIT requestedStateChanged(value);

119 }

120 }

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

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

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

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

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

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

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

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

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

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

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

132 void setExemptFromLifecycle(bool) override {}

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

134 void setInitialSurfaceSize(const QSize &) override {}

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

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

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

138

139 QString m_appId;

140 State m_state;

141 RequestedState m_requestedState;

142 mutable MirSurfaceListModel m_surfaceList;

143};

144

145class ApplicationManager : public ApplicationManagerInterface

146{

147 Q_OBJECT

148

149public:

150

151 int rowCount(const QModelIndex &) const override

152 {

153 return m_applications.count();

154 }

155

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

157 {

158 return QVariant();

159 }

160

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

162

163 ApplicationInfoInterface *get(int index) const override

164 {

165 return m_applications[index];

166 }

167

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

169 {

170 Q_UNUSED(appId);

171 return nullptr;

172 }

173

174 ApplicationInfoInterface *findApplicationWithSurface(MirSurfaceInterface* surface) const override

175 {

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

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

178 return m_applications[i];

179 }

180 }

181 return nullptr;

182 }

183

184 bool requestFocusApplication(const QString &appId) override

185 {

186 Q_UNUSED(appId);

187 return false;

188 }

189

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

191 {

192 Application *application = new Application(appId);

193 prepend(application);

194 return application;

195 }

196

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

198

199private:

200 void prepend(Application *application)

201 {

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

203 m_applications.append(application);

204 endInsertRows();

205 }

206

207 QList<Application*> m_applications;

208};

209

210#endif // UNITYAPPLICATIONMOCKS_H