20b32fc · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Surface-based window management

20b32fcDaniel d'Andrada11 years ago

plugins/CMakeLists.txt+1

compare with xenial

unifiedsplit

@@ -25,4 +25,5 @@ add_subdirectory(Ubuntu)

25add_subdirectory(UInput)

26add_subdirectory(Unity)

27add_subdirectory(Utils)

28+add_subdirectory(WindowManager)

28add_subdirectory(Wizard)

29add_subdirectory(Wizard)

plugins/WindowManager/CMakeLists.txtnew file+13

@@ -0,0 +1,13 @@

1+set(WINDOWMANAGER_SRC

2+ TopLevelSurfaceList.cpp

3+ WindowManagerPlugin.cpp

4+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

5+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

6+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

7+ )

9+add_library(windowmanager-qml SHARED ${WINDOWMANAGER_SRC})

10+

11+qt5_use_modules(windowmanager-qml Qml Quick Gui)

12+

13+add_unity8_plugin(WindowManager 0.1 WindowManager TARGETS windowmanager-qml)

plugins/WindowManager/TopLevelSurfaceList.cppnew file+429

@@ -0,0 +1,429 @@

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+

17+#include "TopLevelSurfaceList.h"

18+

19+// unity-api

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

21+#include <unity/shell/application/MirSurfaceInterface.h>

22+#include <unity/shell/application/MirSurfaceListInterface.h>

23+

24+Q_LOGGING_CATEGORY(UNITY_TOPSURFACELIST, "unity.topsurfacelist")

25+

26+#define DEBUG_MSG qCDebug(UNITY_TOPSURFACELIST).nospace().noquote() << __func__

27+

28+namespace unityapi = unity::shell::application;

29+

30+TopLevelSurfaceList::TopLevelSurfaceList(QObject *parent) :

31+ QAbstractListModel(parent)

32+{

33+ DEBUG_MSG << "()";

34+}

35+

36+TopLevelSurfaceList::~TopLevelSurfaceList()

37+{

38+ DEBUG_MSG << "()";

39+}

40+

41+int TopLevelSurfaceList::rowCount(const QModelIndex &parent) const

42+{

43+ return !parent.isValid() ? m_surfaceList.size() : 0;

44+}

45+

46+QVariant TopLevelSurfaceList::data(const QModelIndex& index, int role) const

47+{

48+ if (index.row() < 0 || index.row() >= m_surfaceList.size())

49+ return QVariant();

50+

51+ if (role == SurfaceRole) {

52+ unityapi::MirSurfaceInterface *surface = m_surfaceList.at(index.row()).surface;

53+ return QVariant::fromValue(surface);

54+ } else if (role == ApplicationRole) {

55+ return QVariant::fromValue(m_surfaceList.at(index.row()).application);

56+ } else if (role == IdRole) {

57+ return QVariant::fromValue(m_surfaceList.at(index.row()).id);

58+ } else {

59+ return QVariant();

60+ }

61+}

62+

63+void TopLevelSurfaceList::raise(unityapi::MirSurfaceInterface *surface)

64+{

65+ if (!surface)

66+ return;

67+

68+ DEBUG_MSG << "(MirSurface[" << (void*)surface << "])";

69+

70+ int i = indexOf(surface);

71+ if (i != -1) {

72+ moveSurface(i, 0);

73+ }

74+}

75+

76+void TopLevelSurfaceList::prependPlaceholder(unityapi::ApplicationInfoInterface *application)

77+{

78+ DEBUG_MSG << "(" << application->appId() << ")";

79+ prependSurfaceHelper(nullptr, application);

80+}

81+

82+void TopLevelSurfaceList::prependSurface(unityapi::MirSurfaceInterface *surface, unityapi::ApplicationInfoInterface *application)

83+{

84+ Q_ASSERT(surface != nullptr);

85+

86+ bool filledPlaceholder = false;

87+ for (int i = 0; i < m_surfaceList.count() && !filledPlaceholder; ++i) {

88+ ModelEntry &entry = m_surfaceList[i];

89+ if (entry.application == application && entry.surface == nullptr) {

90+ entry.surface = surface;

91+ connectSurface(surface);

92+ DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface << ", filling out placeholder. after: " << toString();

93+ Q_EMIT dataChanged(index(i) /* topLeft */, index(i) /* bottomRight */, QVector<int>() << SurfaceRole);

94+ filledPlaceholder = true;

95+ }

96+ }

97+

98+ if (!filledPlaceholder) {

99+ DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface << ", adding new row";

100+ prependSurfaceHelper(surface, application);

101+ }

102+}

103+

104+void TopLevelSurfaceList::prependSurfaceHelper(unityapi::MirSurfaceInterface *surface, unityapi::ApplicationInfoInterface *application)

105+{

106+ beginInsertRows(QModelIndex(), 0 /*first*/, 0 /*last*/);

107+ int id = generateId();

108+ m_surfaceList.prepend(ModelEntry(surface, application, id));

109+ if (surface) {

110+ connectSurface(surface);

111+ }

112+ endInsertRows();

113+ DEBUG_MSG << " after " << toString();

114+ Q_EMIT countChanged();

115+ Q_EMIT listChanged();

116+}

117+

118+void TopLevelSurfaceList::connectSurface(unityapi::MirSurfaceInterface *surface)

119+{

120+ connect(surface, &unityapi::MirSurfaceInterface::focusedChanged, this, [this, surface](bool focused){

121+ if (focused) {

122+ this->raise(surface);

123+ }

124+ });

125+ connect(surface, &unityapi::MirSurfaceInterface::liveChanged, this, [this, surface](bool live){

126+ if (!live) {

127+ onSurfaceDied(surface);

128+ }

129+ });

130+ connect(surface, &QObject::destroyed, this, [this, surface](){ this->onSurfaceDestroyed(surface); });

131+}

132+

133+void TopLevelSurfaceList::onSurfaceDied(unityapi::MirSurfaceInterface *surface)

134+{

135+ int i = indexOf(surface);

136+ if (i == -1) {

137+ return;

138+ }

139+

140+ auto application = m_surfaceList[i].application;

141+

142+ // can't be starting if it already has a surface

143+ Q_ASSERT(application->state() != unityapi::ApplicationInfoInterface::Starting);

144+

145+ if (application->state() == unityapi::ApplicationInfoInterface::Running) {

146+ m_surfaceList[i].removeOnceSurfaceDestroyed = true;

147+ } else {

148+ // assume it got killed by the out-of-memory daemon.

149+ //

150+ // So leave entry in the model and only remove its surface, so shell can display a screenshot

151+ // in its place.

152+ m_surfaceList[i].removeOnceSurfaceDestroyed = false;

153+ }

154+}

155+

156+void TopLevelSurfaceList::onSurfaceDestroyed(unityapi::MirSurfaceInterface *surface)

157+{

158+ int i = indexOf(surface);

159+ if (i == -1) {

160+ return;

161+ }

162+

163+ if (m_surfaceList[i].removeOnceSurfaceDestroyed) {

164+ removeAt(i);

165+ } else {

166+ m_surfaceList[i].surface = nullptr;

167+ Q_EMIT dataChanged(index(i) /* topLeft */, index(i) /* bottomRight */, QVector<int>() << SurfaceRole);

168+ DEBUG_MSG << " Removed surface from entry. After: " << toString();

169+ }

170+}

171+

172+void TopLevelSurfaceList::removeAt(int index)

173+{

174+ beginRemoveRows(QModelIndex(), index, index);

175+ m_surfaceList.removeAt(index);

176+ endRemoveRows();

177+ DEBUG_MSG << " after " << toString();

178+ Q_EMIT countChanged();

179+ Q_EMIT listChanged();

180+}

181+

182+int TopLevelSurfaceList::indexOf(unityapi::MirSurfaceInterface *surface)

183+{

184+ for (int i = 0; i < m_surfaceList.count(); ++i) {

185+ if (m_surfaceList.at(i).surface == surface) {

186+ return i;

187+ }

188+ }

189+ return -1;

190+}

191+

192+void TopLevelSurfaceList::moveSurface(int from, int to)

193+{

194+ if (from == to) return;

195+ DEBUG_MSG << " from=" << from << " to=" << to;

196+

197+ if (from >= 0 && from < m_surfaceList.size() && to >= 0 && to < m_surfaceList.size()) {

198+ QModelIndex parent;

199+ /* When moving an item down, the destination index needs to be incremented

200+ by one, as explained in the documentation:

201+ http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */

202+

203+ beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));

204+ m_surfaceList.move(from, to);

205+ DEBUG_MSG << " after " << toString();

206+ endMoveRows();

207+ Q_EMIT listChanged();

208+ }

209+}

210+

211+unityapi::MirSurfaceInterface *TopLevelSurfaceList::surfaceAt(int index) const

212+{

213+ if (index >=0 && index < m_surfaceList.count()) {

214+ return m_surfaceList[index].surface;

215+ } else {

216+ return nullptr;

217+ }

218+}

219+

220+unityapi::ApplicationInfoInterface *TopLevelSurfaceList::applicationAt(int index) const

221+{

222+ if (index >=0 && index < m_surfaceList.count()) {

223+ return m_surfaceList[index].application;

224+ } else {

225+ return nullptr;

226+ }

227+}

228+

229+int TopLevelSurfaceList::idAt(int index) const

230+{

231+ if (index >=0 && index < m_surfaceList.count()) {

232+ return m_surfaceList[index].id;

233+ } else {

234+ return 0;

235+ }

236+}

237+

238+int TopLevelSurfaceList::indexForId(int id) const

239+{

240+ for (int i = 0; i < m_surfaceList.count(); ++i) {

241+ if (m_surfaceList[i].id == id) {

242+ return i;

243+ }

244+ }

245+ return -1;

246+}

247+

248+void TopLevelSurfaceList::move(int id, int toIndex)

249+{

250+ DEBUG_MSG << " id=" << id << " toIndex=" << toIndex;

251+ int fromIndex = indexForId(id);

252+ if (fromIndex != -1) {

253+ moveSurface(fromIndex, toIndex);

254+ }

255+}

256+

257+int TopLevelSurfaceList::generateId()

258+{

259+ int id = m_nextId;

260+ m_nextId = nextFreeId(m_nextId + 1);

261+ Q_EMIT nextIdChanged();

262+ return id;

263+}

264+

265+int TopLevelSurfaceList::nextFreeId(int candidateId)

266+{

267+ if (candidateId > m_maxId) {

268+ return nextFreeId(1);

269+ } else {

270+ if (indexForId(candidateId) == -1) {

271+ // it's indeed free

272+ return candidateId;

273+ } else {

274+ return nextFreeId(candidateId + 1);

275+ }

276+ }

277+}

278+

279+QString TopLevelSurfaceList::toString()

280+{

281+ QString str;

282+ for (int i = 0; i < m_surfaceList.count(); ++i) {

283+ auto item = m_surfaceList.at(i);

284+

285+ QString itemStr = QString("(index=%1,appId=%2,surface=0x%3,id=%4)")

286+ .arg(i)

287+ .arg(item.application->appId())

288+ .arg((qintptr)item.surface, 0, 16)

289+ .arg(item.id);

290+

291+ if (i > 0) {

292+ str.append(",");

293+ }

294+ str.append(itemStr);

295+ }

296+ return str;

297+}

298+

299+void TopLevelSurfaceList::addApplication(unityapi::ApplicationInfoInterface *application)

300+{

301+ DEBUG_MSG << "(" << application->appId() << ")";

302+ Q_ASSERT(!m_applications.contains(application));

303+ m_applications.append(application);

304+

305+ unityapi::MirSurfaceListInterface *surfaceList = application->surfaceList();

306+

307+ if (application->state() != unityapi::ApplicationInfoInterface::Stopped) {

308+ if (surfaceList->count() == 0) {

309+ prependPlaceholder(application);

310+ } else {

311+ for (int i = 0; i < surfaceList->count(); ++i) {

312+ prependSurface(surfaceList->get(i), application);

313+ }

314+ }

315+ }

316+

317+ connect(surfaceList, &QAbstractItemModel::rowsInserted, this,

318+ [this, application, surfaceList](const QModelIndex & /*parent*/, int first, int last)

319+ {

320+ for (int i = last; i >= first; --i) {

321+ this->prependSurface(surfaceList->get(i), application);

322+ }

323+ });

324+}

325+

326+void TopLevelSurfaceList::removeApplication(unityapi::ApplicationInfoInterface *application)

327+{

328+ DEBUG_MSG << "(" << application->appId() << ")";

329+ Q_ASSERT(m_applications.contains(application));

330+

331+ unityapi::MirSurfaceListInterface *surfaceList = application->surfaceList();

332+

333+ disconnect(surfaceList, 0, this, 0);

334+

335+ int i = 0;

336+ while (i < m_surfaceList.count()) {

337+ if (m_surfaceList.at(i).application == application) {

338+ beginRemoveRows(QModelIndex(), i, i);

339+ m_surfaceList.removeAt(i);

340+ endRemoveRows();

341+ Q_EMIT countChanged();

342+ Q_EMIT listChanged();

343+ } else {

344+ ++i;

345+ }

346+ }

347+

348+ DEBUG_MSG << " after " << toString();

349+

350+ m_applications.removeAll(application);

351+}

352+

353+QAbstractListModel *TopLevelSurfaceList::applicationsModel() const

354+{

355+ return m_applicationsModel;

356+}

357+

358+void TopLevelSurfaceList::setApplicationsModel(QAbstractListModel* value)

359+{

360+ if (m_applicationsModel == value) {

361+ return;

362+ }

363+

364+ DEBUG_MSG << "(" << value << ")";

365+

366+ beginResetModel();

367+

368+ if (m_applicationsModel) {

369+ m_surfaceList.clear();

370+ m_applications.clear();

371+ disconnect(m_applicationsModel, 0, this, 0);

372+ }

373+

374+ m_applicationsModel = value;

375+

376+ if (m_applicationsModel) {

377+ findApplicationRole();

378+

379+ connect(m_applicationsModel, &QAbstractItemModel::rowsInserted,

380+ this, [this](const QModelIndex &/*parent*/, int first, int last) {

381+ for (int i = first; i <= last; ++i) {

382+ auto application = getApplicationFromModelAt(i);

383+ addApplication(application);

384+ }

385+ });

386+

387+ connect(m_applicationsModel, &QAbstractItemModel::rowsAboutToBeRemoved,

388+ this, [this](const QModelIndex &/*parent*/, int first, int last) {

389+ for (int i = first; i <= last; ++i) {

390+ auto application = getApplicationFromModelAt(i);

391+ removeApplication(application);

392+ }

393+ });

394+

395+ for (int i = 0; i < m_applicationsModel->rowCount(); ++i) {

396+ auto application = getApplicationFromModelAt(i);

397+ addApplication(application);

398+ }

399+ }

400+

401+ endResetModel();

402+}

403+

404+unityapi::ApplicationInfoInterface *TopLevelSurfaceList::getApplicationFromModelAt(int index)

405+{

406+ QModelIndex modelIndex = m_applicationsModel->index(index);

407+

408+ QVariant variant = m_applicationsModel->data(modelIndex, m_applicationRole);

409+

410+ // variant.value<unityapi::ApplicationInfoInterface*>() returns null for some reason.

411+ return static_cast<unityapi::ApplicationInfoInterface*>(variant.value<QObject*>());

412+}

413+

414+void TopLevelSurfaceList::findApplicationRole()

415+{

416+ QHash<int, QByteArray> namesHash = m_applicationsModel->roleNames();

417+ QHash<int, QByteArray>::iterator i;

418+

419+ m_applicationRole = -1;

420+ for (i = namesHash.begin(); i != namesHash.end() && m_applicationRole == -1; ++i) {

421+ if (i.value() == "application") {

422+ m_applicationRole = i.key();

423+ }

424+ }

425+

426+ if (m_applicationRole == -1) {

427+ qFatal("TopLevelSurfaceList: applicationsModel must have a \"application\" role.");

428+ }

429+}

plugins/WindowManager/TopLevelSurfaceList.hnew file+211

@@ -0,0 +1,211 @@

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+

17+#ifndef TOPLEVELSURFACELIST_H

18+#define TOPLEVELSURFACELIST_H

19+

20+#include <QAbstractListModel>

21+#include <QList>

22+#include <QLoggingCategory>

23+

24+Q_DECLARE_LOGGING_CATEGORY(UNITY_TOPSURFACELIST)

25+

26+namespace unity {

27+ namespace shell {

28+ namespace application {

29+ class ApplicationInfoInterface;

30+ class MirSurfaceInterface;

31+ }

32+ }

33+}

34+

35+/**

36+ * @brief A model of top-level surfaces

37+ *

38+ * It's an abstraction of top-level application windows.

39+ *

40+ * When an entry first appears, it normaly doesn't have a surface yet, meaning that the application is

41+ * still starting up. A shell should then display a splash screen or saved screenshot of the application

42+ * until its surface comes up.

43+ *

44+ * As applications can have multiple surfaces and you can also have entries without surfaces at all,

45+ * the only way to unambiguously refer to an entry in this model is through its id.

46+ */

47+class TopLevelSurfaceList : public QAbstractListModel

48+{

49+

50+ Q_OBJECT

51+

52+ /**

53+ * @brief A list model of applications.

54+ *

55+ * It's expected to have a role called "application" which returns a ApplicationInfoInterface

56+ */

57+ Q_PROPERTY(QAbstractListModel* applicationsModel READ applicationsModel

58+ WRITE setApplicationsModel

59+ NOTIFY applicationsModelChanged)

60+

61+ /**

62+ * @brief Number of top-level surfaces in this model

63+ *

64+ * This is the same as rowCount, added in order to keep compatibility with QML ListModels.

65+ */

66+ Q_PROPERTY(int count READ rowCount NOTIFY countChanged)

67+

68+ /**

69+ The id to be used on the next entry created

70+ Useful for tests

71+ */

72+ Q_PROPERTY(int nextId READ nextId NOTIFY nextIdChanged)

73+public:

74+

75+ /**

76+ * @brief The Roles supported by the model

77+ *

78+ * SurfaceRole - A MirSurfaceInterface. It will be null if the application is still starting up

79+ * ApplicationRole - An ApplicationInfoInterface

80+ * IdRole - A unique identifier for this entry. Useful to unambiguosly track elements as they move around in the list

81+ */

82+ enum Roles {

83+ SurfaceRole = Qt::UserRole,

84+ ApplicationRole = Qt::UserRole + 1,

85+ IdRole = Qt::UserRole + 2,

86+ };

87+

88+ explicit TopLevelSurfaceList(QObject *parent = nullptr);

89+ virtual ~TopLevelSurfaceList();

90+

91+ // QAbstractItemModel methods

92+ int rowCount(const QModelIndex &parent = QModelIndex()) const override;

93+ QVariant data(const QModelIndex& index, int role) const override;

94+ QHash<int, QByteArray> roleNames() const {

95+ QHash<int, QByteArray> roleNames;

96+ roleNames.insert(SurfaceRole, "surface");

97+ roleNames.insert(ApplicationRole, "application");

98+ roleNames.insert(IdRole, "id");

99+ return roleNames;

100+ }

101+

102+ int nextId() const { return m_nextId; }

103+

104+ QAbstractListModel *applicationsModel() const;

105+ void setApplicationsModel(QAbstractListModel*);

106+

107+public Q_SLOTS:

108+ /**

109+ * @brief Returns the surface at the given index

110+ *

111+ * It will be a nullptr if the application is still starting up and thus hasn't yet created

112+ * and drawn into a surface.

113+ */

114+ unity::shell::application::MirSurfaceInterface *surfaceAt(int index) const;

115+

116+ /**

117+ * @brief Returns the application at the given index

118+ */

119+ unity::shell::application::ApplicationInfoInterface *applicationAt(int index) const;

120+

121+ /**

122+ * @brief Returns the unique id of the element at the given index

123+ */

124+ int idAt(int index) const;

125+

126+ /**

127+ * @brief Returns the index where the row with the given id is located

128+ */

129+ int indexForId(int id) const;

130+

131+ /**

132+ * @brief Moves the row with the given id to the specified index

133+ */

134+ void move(int id, int toIndex);

135+

136+Q_SIGNALS:

137+ void countChanged();

138+

139+ /**

140+ * @brief Emitted when the list changes

141+ *

142+ * Emitted when model gains an element, loses an element or when elements exchange positions.

143+ */

144+ void listChanged();

145+

146+ void nextIdChanged();

147+

148+ void applicationsModelChanged();

149+

150+private:

151+ void addApplication(unity::shell::application::ApplicationInfoInterface *application);

152+ void removeApplication(unity::shell::application::ApplicationInfoInterface *application);

153+

154+ int indexOf(unity::shell::application::MirSurfaceInterface *surface);

155+ void raise(unity::shell::application::MirSurfaceInterface *surface);

156+ void moveSurface(int from, int to);

157+ void prependSurfaceHelper(unity::shell::application::MirSurfaceInterface *surface,

158+ unity::shell::application::ApplicationInfoInterface *application);

159+ void connectSurface(unity::shell::application::MirSurfaceInterface *surface);

160+ int generateId();

161+ int nextFreeId(int candidateId);

162+ QString toString();

163+ void onSurfaceDestroyed(unity::shell::application::MirSurfaceInterface *surface);

164+ void onSurfaceDied(unity::shell::application::MirSurfaceInterface *surface);

165+ void removeAt(int index);

166+ void findApplicationRole();

167+

168+ unity::shell::application::ApplicationInfoInterface *getApplicationFromModelAt(int index);

169+

170+ /*

171+ Placeholder for a future surface from a starting or running application.

172+ Enables shell to give immediate feedback to the user by showing, eg,

173+ a splash screen.

174+

175+ It's a model row containing a null surface and the given application.

176+ */

177+ void prependPlaceholder(unity::shell::application::ApplicationInfoInterface *application);

178+

179+ /*

180+ Adds a model row with the given surface and application

181+

182+ Alternatively, if a placeholder exists for the given application it's

183+ filled with the given surface instead.

184+ */

185+ void prependSurface(unity::shell::application::MirSurfaceInterface *surface,

186+ unity::shell::application::ApplicationInfoInterface *application);

187+

188+ struct ModelEntry {

189+ ModelEntry(unity::shell::application::MirSurfaceInterface *surface, unity::shell::application::ApplicationInfoInterface *application, int id)

190+ : surface(surface), application(application), id(id) {}

191+ unity::shell::application::MirSurfaceInterface *surface;

192+ unity::shell::application::ApplicationInfoInterface *application;

193+ int id;

194+ bool removeOnceSurfaceDestroyed{false};

195+ };

196+

197+ QList<ModelEntry> m_surfaceList;

198+ int m_nextId{1};

199+ static const int m_maxId{1000000};

200+

201+ // applications that are being monitored

202+ QList<unity::shell::application::ApplicationInfoInterface *> m_applications;

203+

204+ QAbstractListModel* m_applicationsModel{nullptr};

205+ int m_applicationRole{-1};

206+};

207+

208+Q_DECLARE_METATYPE(TopLevelSurfaceList*)

209+Q_DECLARE_METATYPE(QAbstractListModel*)

210+

211+#endif // TOPLEVELSURFACELIST_H

plugins/WindowManager/WindowManagerPlugin.cppnew file+28

@@ -0,0 +1,28 @@

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+

17+#include "WindowManagerPlugin.h"

18+

19+#include "TopLevelSurfaceList.h"

20+

21+#include <QtQml>

22+

23+void WindowManagerPlugin::registerTypes(const char *uri)

24+{

25+ qmlRegisterType<TopLevelSurfaceList>(uri, 0, 1, "TopLevelSurfaceList");

26+

27+ qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");

28+}

tests/mocks/Unity/Application/SessionManager.h → plugins/WindowManager/WindowManagerPlugin.hrenamed+10−22

@@ -1,5 +1,5 @@

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

@@ -14,31 +14,19 @@

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

15 */

17−#ifndef SESSIONMANAGER_H

17+#ifndef WINDOWMANAGER_PLUGIN_H

18−#define SESSIONMANAGER_H

18+#define WINDOWMANAGER_PLUGIN_H

20−#include <QObject>

20+#include <QtQml/QQmlEngine>

21+#include <QtQml/QQmlExtensionPlugin>

22−class Session;

23+class WindowManagerPlugin : public QQmlExtensionPlugin

23−

24−class SessionManager : public QObject

25{

24{

26 Q_OBJECT

25 Q_OBJECT

27−public:

26+ Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")

28− explicit SessionManager(QObject *parent = 0);

29−

30− static SessionManager *singleton();

31−

32− Q_INVOKABLE Session* createSession(const QString& name, const QUrl& screenshot);

34− void registerSession(Session *session);

28+public:

35−

29+ void registerTypes(const char *uri) override;

36−Q_SIGNALS:

37− void sessionStarting(Session *session);

38− void sessionStopping(Session *session);

39−

40−private:

41− static SessionManager *the_session_manager;

42};

30};

44−#endif // SESSIONMANAGER_H

32+#endif // WINDOWMANAGER_PLUGIN_H

plugins/WindowManager/qmldirnew file+2

@@ -0,0 +1,2 @@

1+module WindowManager

2+plugin windowmanager-qml

qml/Components/KeymapSwitcher.qml+2−9

@@ -57,16 +57,9 @@ QtObject {

57 currentKeymapIndex = prevIndex;

58 }

60− // Code below will get much simpler with surface-based window management (the upcoming MirFocusController)

61− property var application: ApplicationManager.focusedApplicationId

62− ? ApplicationManager.findApplication(ApplicationManager.focusedApplicationId)

63− : null

64− property var session: application && application.session ? application.session : null

65− property var surface: session ? session.lastSurface : null

66−

67 property Binding surfaceKeymapBinding: Binding {

60 property Binding surfaceKeymapBinding: Binding {

68− target: root.surface

61+ target: MirFocusController.focusedSurface

69− when: root.surface != null && root.surface.live

62+ when: target != null && target.live

70 property: "keymap"

63 property: "keymap"

71 value: root.currentKeymap

64 value: root.currentKeymap

72 }

65 }

qml/Greeter/Greeter.qml+5−4

@@ -64,7 +64,7 @@ Showable {

64 d.selectUser(d.currentIndex, true);

65 }

67− function notifyAppFocused(appId) {

67+ function notifyAppFocusRequested(appId) {

68 if (!active) {

69 return;

70 }

@@ -81,19 +81,20 @@ Showable {

81 }

82 }

84− function notifyAboutToFocusApp(appId) {

84+ // Notify that the user has explicitly requested the given app through unity8 GUI.

85+ function notifyUserRequestedApp(appId) {

85 if (!active) {

86 if (!active) {

86 return;

87 return;

87 }

88 }

89 // A hint that we're about to focus an app. This way we can look

90 // A hint that we're about to focus an app. This way we can look

90 // a little more responsive, rather than waiting for the above

91 // a little more responsive, rather than waiting for the above

91− // notifyAppFocused call. We also need this in case we have a locked

92+ // notifyAppFocusRequested call. We also need this in case we have a locked

92 // app, in order to show lockscreen instead of new app.

93 // app, in order to show lockscreen instead of new app.

93 d.startUnlock(false /* toTheRight */);

94 d.startUnlock(false /* toTheRight */);

94 }

95 }

96− // This is a just a glorified notifyAboutToFocusApp(), but it does one

97+ // This is a just a glorified notifyUserRequestedApp(), but it does one

97 // other thing: it hides any cover pages to the RIGHT, because the user

98 // other thing: it hides any cover pages to the RIGHT, because the user

98 // just came from a launcher drag starting on the left.

99 // just came from a launcher drag starting on the left.

99 // It also returns a boolean value, indicating whether there was a visual

100 // It also returns a boolean value, indicating whether there was a visual

qml/Launcher/LauncherPanel.qml+1

@@ -98,6 +98,7 @@ Rectangle {

98 AbstractButton {

99 id: dashItem

100 anchors.fill: parent

101+ activeFocusOnPress: false

101 onClicked: root.showDashHome()

102 onClicked: root.showDashHome()

102 }

103 }

103 Rectangle {

104 Rectangle {

qml/Shell.qml+64−51

@@ -42,6 +42,7 @@ import Unity.Session 0.1

42import Unity.DashCommunicator 0.1

43import Unity.Indicators 0.1 as Indicators

44import Cursor 1.0

45+import WindowManager 0.1

47Item {

48Item {

@@ -96,12 +97,45 @@ Item {

96 }

97 }

98 }

99− // For autopilot consumption

100− readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId

101−

102− // internal props from here onwards

103 readonly property var mainApp:

100 readonly property var mainApp:

104 applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainApp : null

101 applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainApp : null

102+ onMainAppChanged: {

103+ if (mainApp) {

104+ _makeGreeterReactToAppChange(mainApp.appId);

105+ }

106+

107+ }

108+ Connections {

109+ target: ApplicationManager

110+ onFocusRequested: {

111+ if (shell.mainApp && shell.mainApp.appId === appId) {

112+ _makeGreeterReactToAppChange(appId);

113+ }

114+ }

115+ }

116+ function _makeGreeterReactToAppChange(appId) {

117+ if (tutorial.running && appId != "" && appId != "unity8-dash") {

118+ // If this happens on first boot, we may be in edge

119+ // tutorial or wizard while receiving a call. But a call

120+ // is more important than wizard so just bail out of those.

121+ tutorial.finish();

122+ wizard.hide();

123+ }

124+

125+ if (appId === "dialer-app" && callManager.hasCalls && greeter.locked) {

126+ // If we are in the middle of a call, make dialer lockedApp and show it.

127+ // This can happen if user backs out of dialer back to greeter, then

128+ // launches dialer again.

129+ greeter.lockedApp = appId;

130+ }

131+ greeter.notifyAppFocusRequested(appId);

132+

133+ panel.indicators.hide();

134+ launcher.hide();

135+ }

136+

137+ // For autopilot consumption

138+ readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId

105

139

106 // Disable everything while greeter is waiting, so that the user can't swipe

140 // Disable everything while greeter is waiting, so that the user can't swipe

107 // the greeter or launcher until we know whether the session is locked.

141 // the greeter or launcher until we know whether the session is locked.

@@ -198,36 +232,10 @@ Item {

198 width: parent.width

232 width: parent.width

199 height: parent.height

233 height: parent.height

200

234

201− Connections {

235+ TopLevelSurfaceList {

202− target: ApplicationManager

236+ id: topLevelSurfaceList

203−

237+ objectName: "topLevelSurfaceList"

204− // This signal is also fired when we try to focus the current app

238+ applicationsModel: ApplicationManager

205− // again. We rely on this!

206− onFocusedApplicationIdChanged: {

207− var appId = ApplicationManager.focusedApplicationId;

208−

209− if (wizard.active && appId != "" && appId != "unity8-dash") {

210− // If this happens on first boot, we may be in edge

211− // tutorial or wizard while receiving a call. But a call

212− // is more important than wizard so just bail out of those.

213− tutorial.finish();

214− wizard.hide();

215− }

216−

217− if (appId === "dialer-app" && callManager.hasCalls && greeter.locked) {

218− // If we are in the middle of a call, make dialer lockedApp and show it.

219− // This can happen if user backs out of dialer back to greeter, then

220− // launches dialer again.

221− greeter.lockedApp = appId;

222− }

223− greeter.notifyAppFocused(appId);

224−

225− panel.indicators.hide();

226− }

227−

228− onApplicationAdded: {

229− launcher.hide();

230− }

231 }

239 }

232

240

233 Loader {

241 Loader {

@@ -270,6 +278,11 @@ Item {

270

278

271 onInteractiveChanged: { if (interactive) { focus = true; } }

279 onInteractiveChanged: { if (interactive) { focus = true; } }

272

280

281+ Binding {

282+ target: applicationsDisplayLoader.item

283+ property: "focus"

284+ value: true

285+ }

273 Binding {

286 Binding {

274 target: applicationsDisplayLoader.item

287 target: applicationsDisplayLoader.item

275 property: "objectName"

288 property: "objectName"

@@ -356,6 +369,16 @@ Item {

356 property: "leftMargin"

369 property: "leftMargin"

357 value: shell.usageScenario == "desktop" && !settings.autohideLauncher ? launcher.panelWidth: 0

370 value: shell.usageScenario == "desktop" && !settings.autohideLauncher ? launcher.panelWidth: 0

358 }

371 }

372+ Binding {

373+ target: applicationsDisplayLoader.item

374+ property: "applicationManager"

375+ value: ApplicationManager

376+ }

377+ Binding {

378+ target: applicationsDisplayLoader.item

379+ property: "topLevelSurfaceList"

380+ value: topLevelSurfaceList

381+ }

359 }

382 }

360 }

383 }

361

384

@@ -370,16 +393,6 @@ Item {

370 z: notifications.useModal || panel.indicators.shown || wizard.active || tutorial.running ? overlay.z + 1 : overlay.z - 1

393 z: notifications.useModal || panel.indicators.shown || wizard.active || tutorial.running ? overlay.z + 1 : overlay.z - 1

371 }

394 }

372

395

373− Connections {

374− target: SessionManager

375− onSessionStopping: {

376− if (!session.parentSession && !session.application) {

377− // nothing is using it. delete it right away

378− session.release();

379− }

380− }

381− }

382−

383 Loader {

396 Loader {

384 id: greeterLoader

397 id: greeterLoader

385 anchors.fill: parent

398 anchors.fill: parent

@@ -471,7 +484,7 @@ Item {

471 }

484 }

472

485

473 function showHome() {

486 function showHome() {

474− greeter.notifyAboutToFocusApp("unity8-dash");

487+ greeter.notifyUserRequestedApp("unity8-dash");

475

488

476 var animate = !lightDM.greeter.active && !stages.shown

489 var animate = !lightDM.greeter.active && !stages.shown

477 dash.setCurrentScope(0, animate, false)

490 dash.setCurrentScope(0, animate, false)

@@ -520,9 +533,10 @@ Item {

520 greeterShown: greeter.shown

533 greeterShown: greeter.shown

521 }

534 }

522

535

523− readonly property bool topmostApplicationIsFullscreen: mainApp && mainApp.fullscreen

536+ readonly property bool focusedSurfaceIsFullscreen: MirFocusController.focusedSurface

524−

537+ ? MirFocusController.focusedSurface.state === Mir.FullscreenState

538+ : false

525− fullscreenMode: (topmostApplicationIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)

539+ fullscreenMode: (focusedSurfaceIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)

526 || greeter.hasLockedApp

540 || greeter.hasLockedApp

527 locked: greeter && greeter.active

541 locked: greeter && greeter.active

528 }

542 }

@@ -555,8 +569,7 @@ Item {

555 }

569 }

556 }

570 }

557 onLauncherApplicationSelected: {

571 onLauncherApplicationSelected: {

558− greeter.notifyAboutToFocusApp(appId);

572+ greeter.notifyUserRequestedApp(appId);

559− shell.activateApplication(appId);

560 }

573 }

561 onShownChanged: {

574 onShownChanged: {

562 if (shown) {

575 if (shown) {

@@ -719,7 +732,7 @@ Item {

719 onMouseMoved: { cursor.opacity = 1; }

732 onMouseMoved: { cursor.opacity = 1; }

720 }

733 }

721

734

722− // non-visual item

735+ // non-visual object

723 KeymapSwitcher {}

736 KeymapSwitcher {}

724

737

725 Rectangle {

738 Rectangle {

qml/Stages/AbstractStage.qml+9−2

@@ -18,12 +18,19 @@ import QtQuick 2.4

18import Ubuntu.Components 1.3

19import GSettings 1.0

21−Rectangle {

21+FocusScope {

22 id: root

24+ property alias color: backRect.color

25+ Rectangle {

26+ id: backRect

24− color: "#060606"

27+ color: "#060606"

28+ anchors.fill: parent

29+ }

26 // Controls to be set from outside

31 // Controls to be set from outside

32+ property QtObject applicationManager

33+ property QtObject topLevelSurfaceList

27 property bool altTabPressed

34 property bool altTabPressed

28 property url background

35 property url background

29 property bool beingResized

36 property bool beingResized

qml/Stages/Animations/BaseSessionAnimation.qmldeleted−96

@@ -1,96 +0,0 @@

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−

17−import QtQuick 2.4

18−

19−/* This is the base case for surface animations, used when adding/removing * child surfaces.

20− * The class is meant to be overridden and changes/animations provided for state changes.

21− * NB. It is important to release the surface at the end of the "out" animation.

22− *

23− * Example - Simple fade in/out

24− *

25− * BaseSurfaceAnimation {

26− * outChanges: [ PropertyChanges { target: animation.surface; opacity: 0.0 } ]

27− * outAnimations: [

28− SequentialAnimation {

29− * NumberAnimation { target: animation.surface; property: "opacity"; duration: 300 }

30− * ScriptAction { script: { if (animation.parent.removing) animation.surface.release(); } }

31− * }

32− * ]

33− *

34− * inChanges: [ PropertyChanges { target: animation.surface; opacity: 1.0 } ]

35− * inAnimations: [ NumberAnimation { target: animation.surface; property: "opacity"; duration: 300 } ]

36− * }

37− */

38−Item {

39− id: base

40− property var container

41− objectName: "sessionAnimation"

42−

43− // changes applied when state changes to "from"

44− property list<QtObject> fromChanges

45− // transition animations when changing state to "from"

46− property list<QtObject> fromAnimations

47−

48− // changes applied when state changes to "to"

49− property list<QtObject> toChanges

50− // transition animations when changing state to "to"

51− property list<QtObject> toAnimations

52−

53− function start() {

54− // "prep" state forces toChanges without transition animations.

55− state = "prep"

56− state = "to";

57− }

58− function end() {

59− state = "from";

60− }

61−

62− signal completed()

63−

64− states: [

65− State {

66− name: "baseAnimation"

67− PropertyChanges { target: container; anchors.fill: undefined }

68− },

69−

70− State {

71− name: "prep"

72− extend: "baseAnimation"

73− changes: fromChanges

74− },

75− State {

76− name: "from"

77− extend: "prep"

78− },

79− State {

80− name: "in"

81− extend: "baseAnimation"

82− changes: toChanges

83− }

84− ]

85−

86− transitions: [

87− Transition {

88− to: "from"

89− animations: fromAnimations

90− },

91− Transition {

92− to: "to"

93− animations: toAnimations

94− }

95− ]

96−}

qml/Stages/Animations/SwipeFromBottomAnimation.qmldeleted−53

@@ -1,53 +0,0 @@

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−

17−import QtQuick 2.4

18−import Ubuntu.Components 1.3

19−

20−BaseSessionAnimation {

21− id: animation

22−

23− fromChanges: [

24− AnchorChanges {

25− target: container;

26− anchors.top: container.parent.bottom

27− }

28− ]

29− fromAnimations: [

30− SequentialAnimation {

31− // clip so we don't go out of parent's bounds during spread

32− PropertyAction { target: container.parent; property: "clip"; value: true }

33− AnchorAnimation { easing: UbuntuAnimation.StandardEasing; duration: UbuntuAnimation.BriskDuration }

34− PropertyAction { target: container.parent; property: "clip"; value: false }

35− ScriptAction { script: { animation.completed(); } }

36− }

37− ]

38−

39− toChanges: [

40− AnchorChanges {

41− target: container;

42− anchors.top: container.parent.top

43− }

44− ]

45− toAnimations: [

46− SequentialAnimation {

47− // clip so we don't go out of parent's bounds during spread

48− PropertyAction { target: container.parent; property: "clip"; value: true }

49− AnchorAnimation { easing: UbuntuAnimation.StandardEasing; duration: UbuntuAnimation.BriskDuration }

50− PropertyAction { target: container.parent; property: "clip"; value: false }

51− }

52− ]

53−}

qml/Stages/ApplicationWindow.qml+106−68

@@ -20,35 +20,73 @@ import Unity.Application 0.1

21FocusScope {

22 id: root

23− implicitWidth: sessionContainer.implicitWidth

23+ implicitWidth: surfaceContainer.implicitWidth

24− implicitHeight: sessionContainer.implicitHeight

24+ implicitHeight: surfaceContainer.implicitHeight

26 // to be read from outside

27− property alias interactive: sessionContainer.interactive

27+ property alias interactive: surfaceContainer.interactive

28 property bool orientationChangesEnabled: d.supportsSurfaceResize ? d.surfaceOldEnoughToBeResized : true

29− readonly property string title: sessionContainer.surface && sessionContainer.surface.name !== "" ?

29+ readonly property string title: surface && surface.name !== "" ? surface.name + " - " + d.name : d.name

30− sessionContainer.surface.name : d.name

32 // overridable from outside

31 // overridable from outside

33− property bool fullscreen: application ? application.fullscreen : false

32+ property bool fullscreen: {

33+ if (surface) {

34+ return surface.state === Mir.FullscreenState;

35+ } else if (application) {

36+ return application.fullscreen;

37+ } else {

38+ return false;

39+ }

40+ }

35 // to be set from outside

42 // to be set from outside

43+ property QtObject surface

36 property QtObject application

44 property QtObject application

37 property int surfaceOrientationAngle

45 property int surfaceOrientationAngle

38− property alias resizeSurface: sessionContainer.resizeSurface

46+ property alias resizeSurface: surfaceContainer.resizeSurface

39 property int requestedWidth: -1

47 property int requestedWidth: -1

40 property int requestedHeight: -1

48 property int requestedHeight: -1

42− readonly property int minimumWidth: sessionContainer.surface ? sessionContainer.surface.minimumWidth : 0

50+ readonly property int minimumWidth: surface ? surface.minimumWidth : 0

43− readonly property int minimumHeight: sessionContainer.surface ? sessionContainer.surface.minimumHeight : 0

51+ readonly property int minimumHeight: surface ? surface.minimumHeight : 0

44− readonly property int maximumWidth: sessionContainer.surface ? sessionContainer.surface.maximumWidth : 0

52+ readonly property int maximumWidth: surface ? surface.maximumWidth : 0

45− readonly property int maximumHeight: sessionContainer.surface ? sessionContainer.surface.maximumHeight : 0

53+ readonly property int maximumHeight: surface ? surface.maximumHeight : 0

46− readonly property int widthIncrement: sessionContainer.surface ? sessionContainer.surface.widthIncrement : 0

54+ readonly property int widthIncrement: surface ? surface.widthIncrement : 0

47− readonly property int heightIncrement: sessionContainer.surface ? sessionContainer.surface.heightIncrement : 0

55+ readonly property int heightIncrement: surface ? surface.heightIncrement : 0

56+

57+ onSurfaceChanged: {

58+ if (surface) {

59+ surfaceContainer.surface = surface;

60+ d.liveSurface = surface.live;

61+ d.hadSurface = false;

62+ surfaceInitTimer.start();

63+ } else {

64+ if (d.surfaceInitialized) {

65+ d.hadSurface = true;

66+ }

67+ d.surfaceInitialized = false;

68+ surfaceContainer.surface = null;

69+ }

70+ }

49 QtObject {

72 QtObject {

50 id: d

73 id: d

75+ property bool liveSurface: false;

76+ property var con: Connections {

77+ target: root.surface

78+ onLiveChanged: d.liveSurface = root.surface.live

79+ }

80+ // using liveSurface instead of root.surface.live because with the latter

81+ // this expression is not reevaluated when root.surface.live changes

82+ property bool needToTakeScreenshot: root.surface && d.surfaceInitialized && !d.liveSurface

83+ && applicationState !== ApplicationInfoInterface.Running

84+ onNeedToTakeScreenshotChanged: {

85+ if (needToTakeScreenshot && screenshotImage.status === Image.Null) {

86+ screenshotImage.take();

87+ }

88+ }

89+

52 // helpers so that we don't have to check for the existence of an application everywhere

90 // helpers so that we don't have to check for the existence of an application everywhere

53 // (in order to avoid breaking qml binding due to a javascript exception)

91 // (in order to avoid breaking qml binding due to a javascript exception)

54 readonly property string name: root.application ? root.application.name : ""

92 readonly property string name: root.application ? root.application.name : ""

@@ -62,17 +100,7 @@ FocusScope {

62 readonly property color splashColorFooter: root.application ? root.application.splashColorFooter : "#00000000"

100 readonly property color splashColorFooter: root.application ? root.application.splashColorFooter : "#00000000"

101

64 // Whether the Application had a surface before but lost it.

102 // Whether the Application had a surface before but lost it.

65− property bool hadSurface: sessionContainer.surfaceContainer.hadSurface

103+ property bool hadSurface: false

66−

67− readonly property bool needToTakeScreenshot:

68− ((sessionContainer.surface && d.surfaceInitialized) || d.hadSurface)

69− && screenshotImage.status === Image.Null

70− && d.applicationState === ApplicationInfoInterface.Stopped

71− onNeedToTakeScreenshotChanged: {

72− if (needToTakeScreenshot) {

73− screenshotImage.take();

74− }

75− }

104

77 //FIXME - this is a hack to avoid the first few rendered frames as they

105 //FIXME - this is a hack to avoid the first few rendered frames as they

78 // might show the UI accommodating due to surface resizes on startup.

106 // might show the UI accommodating due to surface resizes on startup.

@@ -99,7 +127,9 @@ FocusScope {

99 Timer {

127 Timer {

100 id: surfaceInitTimer

128 id: surfaceInitTimer

101 interval: 100

129 interval: 100

130+ onTriggered: {

102− onTriggered: { if (sessionContainer.surface) {d.surfaceInitialized = true;} }

131+ if (root.surface && root.surface.live) {d.surfaceInitialized = true;}

132+ }

103 }

133 }

104

134

105 Timer {

135 Timer {

@@ -117,7 +147,7 @@ FocusScope {

117 function take() {

147 function take() {

118 // Save memory by using a half-resolution (thus quarter size) screenshot.

148 // Save memory by using a half-resolution (thus quarter size) screenshot.

119 // Do not make this a binding, we can only take the screenshot once!

149 // Do not make this a binding, we can only take the screenshot once!

120− sessionContainer.grabToImage(

150+ surfaceContainer.grabToImage(

121 function(result) {

151 function(result) {

122 screenshotImage.source = result.url;

152 screenshotImage.source = result.url;

123 },

153 },

@@ -144,46 +174,33 @@ FocusScope {

144 }

174 }

145 }

175 }

146

176

147− SessionContainer {

177+ SurfaceContainer {

148− id: sessionContainer

178+ id: surfaceContainer

149− // A fake application might not even have a session property.

150− session: application && application.session ? application.session : null

151−

152 requestedWidth: root.requestedWidth

179 requestedWidth: root.requestedWidth

153 requestedHeight: root.requestedHeight

180 requestedHeight: root.requestedHeight

154−

155 surfaceOrientationAngle: application && application.rotatesWindowContents ? root.surfaceOrientationAngle : 0

181 surfaceOrientationAngle: application && application.rotatesWindowContents ? root.surfaceOrientationAngle : 0

156−

157− onSurfaceChanged: {

158− if (sessionContainer.surface) {

159− surfaceInitTimer.start();

160− } else {

161− d.surfaceInitialized = false;

162− }

163− }

164−

165 focus: true

182 focus: true

166 }

183 }

167

184

168− // SessionContainer size drives ApplicationWindow size

185+ // SurfaceContainer size drives ApplicationWindow size

169 Binding {

186 Binding {

170 target: root; property: "width"

187 target: root; property: "width"

171− value: stateGroup.state === "surface" ? sessionContainer.width : root.requestedWidth

188+ value: stateGroup.state === "surface" ? surfaceContainer.width : root.requestedWidth

172 when: root.requestedWidth >= 0

189 when: root.requestedWidth >= 0

173 }

190 }

174 Binding {

191 Binding {

175 target: root; property: "height"

192 target: root; property: "height"

176− value: stateGroup.state === "surface" ? sessionContainer.height : root.requestedHeight

193+ value: stateGroup.state === "surface" ? surfaceContainer.height : root.requestedHeight

177 when: root.requestedHeight >= 0

194 when: root.requestedHeight >= 0

178 }

195 }

179

196

180− // ApplicationWindow size drives SessionContainer size

197+ // ApplicationWindow size drives SurfaceContainer size

181 Binding {

198 Binding {

182− target: sessionContainer; property: "width"; value: root.width

199+ target: surfaceContainer; property: "width"; value: root.width

183 when: root.requestedWidth < 0

200 when: root.requestedWidth < 0

184 }

201 }

185 Binding {

202 Binding {

186− target: sessionContainer; property: "height"; value: root.height

203+ target: surfaceContainer; property: "height"; value: root.height

187 when: root.requestedHeight < 0

204 when: root.requestedHeight < 0

188 }

205 }

189

206

@@ -194,32 +211,43 @@ FocusScope {

194 State {

211 State {

195 name: "void"

212 name: "void"

196 when:

213 when:

197− d.hadSurface && (!sessionContainer.surface || !d.surfaceInitialized)

214+ d.hadSurface && (!root.surface || !d.surfaceInitialized)

198 &&

215 &&

199 screenshotImage.status !== Image.Ready

216 screenshotImage.status !== Image.Ready

200 },

217 },

201 State {

218 State {

202 name: "splashScreen"

219 name: "splashScreen"

203 when:

220 when:

204− !d.hadSurface && (!sessionContainer.surface || !d.surfaceInitialized)

221+ !d.hadSurface && (!root.surface || !d.surfaceInitialized)

205 &&

222 &&

206 screenshotImage.status !== Image.Ready

223 screenshotImage.status !== Image.Ready

207 },

224 },

208 State {

225 State {

209 name: "surface"

226 name: "surface"

210 when:

227 when:

211− (sessionContainer.surface && d.surfaceInitialized)

228+ (root.surface && d.surfaceInitialized)

212 &&

229 &&

230+ (d.liveSurface ||

213− (d.applicationState !== ApplicationInfoInterface.Stopped

231+ (d.applicationState !== ApplicationInfoInterface.Running

214− || screenshotImage.status !== Image.Ready)

232+ && screenshotImage.status !== Image.Ready))

215 },

233 },

216 State {

234 State {

217 name: "screenshot"

235 name: "screenshot"

218 when:

236 when:

219 screenshotImage.status === Image.Ready

237 screenshotImage.status === Image.Ready

220 &&

238 &&

221− (d.applicationState === ApplicationInfoInterface.Stopped

239+ (d.applicationState !== ApplicationInfoInterface.Running

222− || !sessionContainer.surface || !d.surfaceInitialized)

240+ || !root.surface || !d.surfaceInitialized)

241+ },

242+ State {

243+ // This is a dead end. From here we expect the surface to be removed from the model

244+ // shortly after we stop referencing to it in our SurfaceContainer.

245+ name: "closed"

246+ when:

247+ // The surface died while the application is running. It must have been closed

248+ // by the shell or the application decided to destroy it by itself

249+ root.surface && d.surfaceInitialized && !d.liveSurface

250+ && d.applicationState === ApplicationInfoInterface.Running

223 }

251 }

224 ]

252 ]

225

253

@@ -227,17 +255,17 @@ FocusScope {

227 Transition {

255 Transition {

228 from: ""; to: "splashScreen"

256 from: ""; to: "splashScreen"

229 PropertyAction { target: splashLoader; property: "active"; value: true }

257 PropertyAction { target: splashLoader; property: "active"; value: true }

230− PropertyAction { target: sessionContainer.surfaceContainer

258+ PropertyAction { target: surfaceContainer

231 property: "visible"; value: false }

259 property: "visible"; value: false }

232 },

260 },

233 Transition {

261 Transition {

234 from: "splashScreen"; to: "surface"

262 from: "splashScreen"; to: "surface"

235 SequentialAnimation {

263 SequentialAnimation {

236− PropertyAction { target: sessionContainer.surfaceContainer

264+ PropertyAction { target: surfaceContainer

237 property: "opacity"; value: 0.0 }

265 property: "opacity"; value: 0.0 }

238− PropertyAction { target: sessionContainer.surfaceContainer

266+ PropertyAction { target: surfaceContainer

239 property: "visible"; value: true }

267 property: "visible"; value: true }

240− UbuntuNumberAnimation { target: sessionContainer.surfaceContainer; property: "opacity";

268+ UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";

241 from: 0.0; to: 1.0

269 from: 0.0; to: 1.0

242 duration: UbuntuAnimation.BriskDuration }

270 duration: UbuntuAnimation.BriskDuration }

243 ScriptAction { script: {

271 ScriptAction { script: {

@@ -253,12 +281,12 @@ FocusScope {

253 surfaceIsOldTimer.stop();

281 surfaceIsOldTimer.stop();

254 d.surfaceOldEnoughToBeResized = false;

282 d.surfaceOldEnoughToBeResized = false;

255 splashLoader.active = true;

283 splashLoader.active = true;

256− sessionContainer.surfaceContainer.visible = true;

284+ surfaceContainer.visible = true;

257 } }

285 } }

258 UbuntuNumberAnimation { target: splashLoader; property: "opacity";

286 UbuntuNumberAnimation { target: splashLoader; property: "opacity";

259 from: 0.0; to: 1.0

287 from: 0.0; to: 1.0

260 duration: UbuntuAnimation.BriskDuration }

288 duration: UbuntuAnimation.BriskDuration }

261− PropertyAction { target: sessionContainer.surfaceContainer

289+ PropertyAction { target: surfaceContainer

262 property: "visible"; value: false }

290 property: "visible"; value: false }

263 }

291 }

264 },

292 },

@@ -274,15 +302,16 @@ FocusScope {

274 from: 0.0; to: 1.0

302 from: 0.0; to: 1.0

275 duration: UbuntuAnimation.BriskDuration }

303 duration: UbuntuAnimation.BriskDuration }

276 ScriptAction { script: {

304 ScriptAction { script: {

277− sessionContainer.surfaceContainer.visible = false;

305+ surfaceContainer.visible = false;

278− if (sessionContainer.session) { sessionContainer.session.release(); }

306+ surfaceContainer.surface = null;

307+ d.hadSurface = true;

279 } }

308 } }

280 }

309 }

281 },

310 },

282 Transition {

311 Transition {

283 from: "screenshot"; to: "surface"

312 from: "screenshot"; to: "surface"

284 SequentialAnimation {

313 SequentialAnimation {

285− PropertyAction { target: sessionContainer.surfaceContainer

314+ PropertyAction { target: surfaceContainer

286 property: "visible"; value: true }

315 property: "visible"; value: true }

287 UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

316 UbuntuNumberAnimation { target: screenshotImage; property: "opacity";

288 from: 1.0; to: 0.0

317 from: 1.0; to: 0.0

@@ -310,22 +339,31 @@ FocusScope {

310 ScriptAction { script: {

339 ScriptAction { script: {

311 surfaceIsOldTimer.stop();

340 surfaceIsOldTimer.stop();

312 d.surfaceOldEnoughToBeResized = false;

341 d.surfaceOldEnoughToBeResized = false;

313− sessionContainer.surfaceContainer.visible = false;

342+ surfaceContainer.visible = false;

314− if (sessionContainer.session) { sessionContainer.session.release(); }

315 } }

343 } }

316 },

344 },

317 Transition {

345 Transition {

318 from: "void"; to: "surface"

346 from: "void"; to: "surface"

319 SequentialAnimation {

347 SequentialAnimation {

320− PropertyAction { target: sessionContainer.surfaceContainer; property: "opacity"; value: 0.0 }

348+ PropertyAction { target: surfaceContainer; property: "opacity"; value: 0.0 }

321− PropertyAction { target: sessionContainer.surfaceContainer; property: "visible"; value: true }

349+ PropertyAction { target: surfaceContainer; property: "visible"; value: true }

322− UbuntuNumberAnimation { target: sessionContainer.surfaceContainer; property: "opacity";

350+ UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";

323 from: 0.0; to: 1.0

351 from: 0.0; to: 1.0

324 duration: UbuntuAnimation.BriskDuration }

352 duration: UbuntuAnimation.BriskDuration }

325 ScriptAction { script: {

353 ScriptAction { script: {

326 surfaceIsOldTimer.start();

354 surfaceIsOldTimer.start();

327 } }

355 } }

328 }

356 }

357+ },

358+ Transition {

359+ to: "closed"

360+ SequentialAnimation {

361+ ScriptAction { script: {

362+ surfaceContainer.visible = false;

363+ surfaceContainer.surface = null;

364+ d.hadSurface = true;

365+ } }

366+ }

329 }

367 }

330 ]

368 ]

331 }

369 }

qml/Stages/DecoratedWindow.qml+4−4

@@ -26,8 +26,8 @@ FocusScope {

26 width: applicationWindow.width

27 height: (decorationShown ? decoration.height : 0) + applicationWindow.height

29− property alias window: applicationWindow

30 property alias application: applicationWindow.application

29 property alias application: applicationWindow.application

30+ property alias surface: applicationWindow.surface

31 property alias active: decoration.active

32 property alias title: decoration.title

33 property alias fullscreen: applicationWindow.fullscreen

@@ -79,11 +79,11 @@ FocusScope {

79 WindowDecoration {

80 id: decoration

81 target: root.parent

82− objectName: application ? "appWindowDecoration_" + application.appId : "appWindowDecoration_null"

82+ objectName: "appWindowDecoration"

83 anchors { left: parent.left; top: parent.top; right: parent.right }

84 height: units.gu(3)

85 width: root.width

86− title: window.title

86+ title: applicationWindow.title

87 visible: root.decorationShown

89 onClose: root.close();

@@ -94,7 +94,7 @@ FocusScope {

95 ApplicationWindow {

96 id: applicationWindow

97− objectName: application ? "appWindow_" + application.appId : "appWindow_null"

97+ objectName: "appWindow"

98 anchors.top: parent.top

99 anchors.topMargin: decoration.height

100 anchors.left: parent.left

qml/Stages/DesktopSpread.qml+20−18

@@ -1,5 +1,5 @@

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

@@ -20,6 +20,7 @@ import Ubuntu.Components 1.3

20import Ubuntu.Gestures 0.1

21import Unity.Application 0.1

22import "../Components"

23+import Utils 0.1

24FocusScope {

25FocusScope {

25 id: root

26 id: root

@@ -69,12 +70,12 @@ FocusScope {

69 }

70 }

71 function selectNext(isAutoRepeat) {

72 function selectNext(isAutoRepeat) {

72− if (isAutoRepeat && spreadRepeater.highlightedIndex >= ApplicationManager.count -1) {

73+ if (isAutoRepeat && spreadRepeater.highlightedIndex >= topLevelSurfaceList.count -1) {

73 return; // AutoRepeat is not allowed to wrap around

74 return; // AutoRepeat is not allowed to wrap around

74 }

75 }

76− spreadRepeater.highlightedIndex = (spreadRepeater.highlightedIndex + 1) % ApplicationManager.count;

77+ spreadRepeater.highlightedIndex = (spreadRepeater.highlightedIndex + 1) % topLevelSurfaceList.count;

77− var newContentX = ((spreadFlickable.contentWidth) / (ApplicationManager.count + 1)) * Math.max(0, Math.min(ApplicationManager.count - 5, spreadRepeater.highlightedIndex - 3));

78+ var newContentX = ((spreadFlickable.contentWidth) / (topLevelSurfaceList.count + 1)) * Math.max(0, Math.min(topLevelSurfaceList.count - 5, spreadRepeater.highlightedIndex - 3));

78 if (spreadFlickable.contentX < newContentX || spreadRepeater.highlightedIndex == 0) {

79 if (spreadFlickable.contentX < newContentX || spreadRepeater.highlightedIndex == 0) {

79 spreadFlickable.snapTo(newContentX)

80 spreadFlickable.snapTo(newContentX)

80 }

81 }

@@ -85,10 +86,10 @@ FocusScope {

85 return; // AutoRepeat is not allowed to wrap around

86 return; // AutoRepeat is not allowed to wrap around

86 }

87 }

88− var newIndex = spreadRepeater.highlightedIndex - 1 >= 0 ? spreadRepeater.highlightedIndex - 1 : ApplicationManager.count - 1;

89+ var newIndex = spreadRepeater.highlightedIndex - 1 >= 0 ? spreadRepeater.highlightedIndex - 1 : topLevelSurfaceList.count - 1;

89 spreadRepeater.highlightedIndex = newIndex;

90 spreadRepeater.highlightedIndex = newIndex;

90− var newContentX = ((spreadFlickable.contentWidth) / (ApplicationManager.count + 1)) * Math.max(0, Math.min(ApplicationManager.count - 5, spreadRepeater.highlightedIndex - 1));

91+ var newContentX = ((spreadFlickable.contentWidth) / (topLevelSurfaceList.count + 1)) * Math.max(0, Math.min(topLevelSurfaceList.count - 5, spreadRepeater.highlightedIndex - 1));

91− if (spreadFlickable.contentX > newContentX || newIndex == ApplicationManager.count -1) {

92+ if (spreadFlickable.contentX > newContentX || newIndex == topLevelSurfaceList.count -1) {

92 spreadFlickable.snapTo(newContentX)

93 spreadFlickable.snapTo(newContentX)

93 }

94 }

95 }

@@ -98,8 +99,8 @@ FocusScope {

98 if (spreadContainer.visible) {

99 if (spreadContainer.visible) {

99 root.playFocusAnimation(spreadRepeater.highlightedIndex)

100 root.playFocusAnimation(spreadRepeater.highlightedIndex)

100 }

101 }

101− var application = ApplicationManager.get(spreadRepeater.highlightedIndex);

102+ var surface = topLevelSurfaceList.surfaceAt(spreadRepeater.highlightedIndex);

102− ApplicationManager.requestFocusApplication(application.appId);

103+ surface.requestFocus();

103 }

104 }

105 }

105

106

@@ -144,7 +145,7 @@ FocusScope {

144 Repeater {

145 Repeater {

145 id: spreadRepeater

146 id: spreadRepeater

146 objectName: "spreadRepeater"

147 objectName: "spreadRepeater"

147− model: ApplicationManager

148+ model: topLevelSurfaceList

148

149

149 property int highlightedIndex: -1

150 property int highlightedIndex: -1

150 property int closingIndex: -1

151 property int closingIndex: -1

@@ -182,7 +183,8 @@ FocusScope {

182 objectName: "clippedSpreadDelegate"

183 objectName: "clippedSpreadDelegate"

183 anchors.left: parent.left

184 anchors.left: parent.left

184 anchors.top: parent.top

185 anchors.top: parent.top

185− application: ApplicationManager.get(index)

186+ application: model.application

187+ surface: model.surface

186 width: spreadMaths.spreadHeight

188 width: spreadMaths.spreadHeight

187 height: spreadMaths.spreadHeight

189 height: spreadMaths.spreadHeight

188

190

@@ -216,7 +218,7 @@ FocusScope {

216 id: spreadMaths

218 id: spreadMaths

217 flickable: spreadFlickable

219 flickable: spreadFlickable

218 itemIndex: index

220 itemIndex: index

219− totalItems: Math.max(6, ApplicationManager.count)

221+ totalItems: Math.max(6, topLevelSurfaceList.count)

220 sceneHeight: root.height

222 sceneHeight: root.height

221 itemHeight: spreadDelegate.height

223 itemHeight: spreadDelegate.height

222 }

224 }

@@ -310,7 +312,7 @@ FocusScope {

310 Layout.preferredWidth: height * 8 / 7.6

312 Layout.preferredWidth: height * 8 / 7.6

311 image: Image {

313 image: Image {

312 anchors.fill: parent

314 anchors.fill: parent

313− source: model.icon

315+ source: model.application.icon

314 Rectangle {

316 Rectangle {

315 anchors.fill: parent

317 anchors.fill: parent

316 color: "black"

318 color: "black"

@@ -324,7 +326,7 @@ FocusScope {

324 Label {

326 Label {

325 Layout.fillWidth: true

327 Layout.fillWidth: true

326 Layout.preferredHeight: units.gu(6)

328 Layout.preferredHeight: units.gu(6)

327− text: model.name

329+ text: model.surface ? model.surface.name : ""

328 wrapMode: Text.WordWrap

330 wrapMode: Text.WordWrap

329 elide: Text.ElideRight

331 elide: Text.ElideRight

330 maximumLineCount: 2

332 maximumLineCount: 2

@@ -354,7 +356,7 @@ FocusScope {

354 anchors.margins: -units.gu(2)

356 anchors.margins: -units.gu(2)

355 onClicked: {

357 onClicked: {

356 spreadRepeater.closingIndex = index;

358 spreadRepeater.closingIndex = index;

357− ApplicationManager.stopApplication(model.appId)

359+ model.surface.close();

358 }

360 }

359 }

361 }

360 }

362 }

@@ -421,7 +423,7 @@ FocusScope {

421 objectName: "spreadFlickable"

423 objectName: "spreadFlickable"

422 anchors.fill: parent

424 anchors.fill: parent

423 property int minContentWidth: 6 * Math.min(height / 4, width / 5)

425 property int minContentWidth: 6 * Math.min(height / 4, width / 5)

424− contentWidth: Math.max(6, ApplicationManager.count) * Math.min(height / 4, width / 5)

426+ contentWidth: Math.max(6, topLevelSurfaceList.count) * Math.min(height / 4, width / 5)

425 enabled: false

427 enabled: false

426

428

427 function snapTo(contentX) {

429 function snapTo(contentX) {

@@ -523,7 +525,7 @@ FocusScope {

523 Label {

525 Label {

524 id: currentSelectedLabel

526 id: currentSelectedLabel

525 anchors { bottom: parent.bottom; bottomMargin: root.height * 0.625; horizontalCenter: parent.horizontalCenter }

527 anchors { bottom: parent.bottom; bottomMargin: root.height * 0.625; horizontalCenter: parent.horizontalCenter }

526− text: spreadRepeater.highlightedIndex >= 0 ? ApplicationManager.get(spreadRepeater.highlightedIndex).name : ""

528+ text: spreadRepeater.highlightedIndex >= 0 ? topLevelSurfaceList.surfaceAt(spreadRepeater.highlightedIndex).name : ""

527 visible: false

529 visible: false

528 fontSize: "large"

530 fontSize: "large"

529 }

531 }

@@ -545,7 +547,7 @@ FocusScope {

545 from: "*"

547 from: "*"

546 to: "altTab"

548 to: "altTab"

547 SequentialAnimation {

549 SequentialAnimation {

548− PropertyAction { target: spreadRepeater; property: "highlightedIndex"; value: Math.min(ApplicationManager.count - 1, 1) }

550+ PropertyAction { target: spreadRepeater; property: "highlightedIndex"; value: Math.min(topLevelSurfaceList.count - 1, 1) }

549 PauseAnimation { duration: spreadContainer.animateIn ? 0 : 140 }

551 PauseAnimation { duration: spreadContainer.animateIn ? 0 : 140 }

550 PropertyAction { target: workspaceSelector; property: "visible" }

552 PropertyAction { target: workspaceSelector; property: "visible" }

551 PropertyAction { target: spreadContainer; property: "visible" }

553 PropertyAction { target: spreadContainer; property: "visible" }

qml/Stages/DesktopSpreadDelegate.qml+4−3

@@ -1,5 +1,5 @@

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

@@ -25,12 +25,13 @@ Item {

26 property alias window: applicationWindow

27 property alias application: applicationWindow.application

28+ property alias surface: applicationWindow.surface

29 property bool highlightShown: false

30 property bool highlightShown: false

30 property real shadowOpacity: 1

31 property real shadowOpacity: 1

32− property int windowWidth: application && application.session && application.session.lastSurface ? application.session.lastSurface.size.width : 0

33+ property int windowWidth: surface ? surface.size.width : 0

33− property int windowHeight: application && application.session && application.session.lastSurface ? application.session.lastSurface.size.height : 0

34+ property int windowHeight: surface ? surface.size.height : 0

35 state: "normal"

36 state: "normal"

36 states: [

37 states: [

qml/Stages/DesktopStage.qml+110−82

@@ -39,45 +39,18 @@ AbstractStage {

39 // Used by TutorialRight

40 property bool spreadShown: spread.state == "altTab"

42− mainApp: ApplicationManager.focusedApplicationId

42+ mainApp: priv.focusedAppDelegate ? priv.focusedAppDelegate.application : null

43− ? ApplicationManager.findApplication(ApplicationManager.focusedApplicationId)

44− : null

46 // application windows never rotate independently

44 // application windows never rotate independently

47 mainAppWindowOrientationAngle: shellOrientationAngle

45 mainAppWindowOrientationAngle: shellOrientationAngle

49 orientationChangesEnabled: true

47 orientationChangesEnabled: true

51− Connections {

52− target: ApplicationManager

53− onApplicationAdded: {

54− if (spread.state == "altTab") {

55− spread.state = "";

56− }

57−

58− ApplicationManager.focusApplication(appId);

59− }

60−

61− onApplicationRemoved: {

62− priv.focusNext();

63− }

64−

65− onFocusRequested: {

66− var appIndex = priv.indexOf(appId);

67− var appDelegate = appRepeater.itemAt(appIndex);

68− appDelegate.restore();

69−

70− if (spread.state == "altTab") {

71− spread.cancel();

72− }

73− }

74− }

75−

76 GlobalShortcut {

49 GlobalShortcut {

77 id: closeWindowShortcut

50 id: closeWindowShortcut

78 shortcut: Qt.AltModifier|Qt.Key_F4

51 shortcut: Qt.AltModifier|Qt.Key_F4

79− onTriggered: ApplicationManager.stopApplication(priv.focusedAppId)

52+ onTriggered: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }

80− active: priv.focusedAppId !== ""

53+ active: priv.focusedAppDelegate !== null

81 }

54 }

83 GlobalShortcut {

56 GlobalShortcut {

@@ -121,19 +94,31 @@ AbstractStage {

121 active: priv.focusedAppDelegate !== null

94 active: priv.focusedAppDelegate !== null

122 }

95 }

123

97+ Connections {

98+ target: root.topLevelSurfaceList

99+ onCountChanged: {

100+ if (spread.state == "altTab") {

101+ spread.cancel();

102+ }

103+ }

104+ }

105+

124 QtObject {

106 QtObject {

125 id: priv

107 id: priv

108+ objectName: "DesktopStagePrivate"

126

109

127− readonly property string focusedAppId: ApplicationManager.focusedApplicationId

128− readonly property var focusedAppDelegate: {

110+ property var focusedAppDelegate: null

129− var index = indexOf(focusedAppId);

111+ onFocusedAppDelegateChanged: {

130− return index >= 0 && index < appRepeater.count ? appRepeater.itemAt(index) : null

112+ if (spread.state == "altTab") {

113+ spread.state = "";

114+ }

115+ updateForegroundMaximizedApp();

131 }

116 }

132− onFocusedAppDelegateChanged: updateForegroundMaximizedApp();

133

117

134 property int foregroundMaximizedAppZ: -1

118 property int foregroundMaximizedAppZ: -1

135 property int foregroundMaximizedAppIndex: -1 // for stuff like drop shadow and focusing maximized app by clicking panel

119 property int foregroundMaximizedAppIndex: -1 // for stuff like drop shadow and focusing maximized app by clicking panel

136

120

121+

137 function updateForegroundMaximizedApp() {

122 function updateForegroundMaximizedApp() {

138 var tmp = -1;

123 var tmp = -1;

139 var tmpAppId = -1;

124 var tmpAppId = -1;

@@ -148,15 +133,6 @@ AbstractStage {

148 foregroundMaximizedAppIndex = tmpAppId;

133 foregroundMaximizedAppIndex = tmpAppId;

149 }

134 }

150

135

151− function indexOf(appId) {

152− for (var i = 0; i < ApplicationManager.count; i++) {

153− if (ApplicationManager.get(i).appId == appId) {

154− return i;

155− }

156− }

157− return -1;

158− }

159−

160 function minimizeAllWindows() {

136 function minimizeAllWindows() {

161 for (var i = 0; i < appRepeater.count; i++) {

137 for (var i = 0; i < appRepeater.count; i++) {

162 var appDelegate = appRepeater.itemAt(i);

138 var appDelegate = appRepeater.itemAt(i);

@@ -165,15 +141,14 @@ AbstractStage {

165 }

141 }

166 }

142 }

167

143

168− ApplicationManager.unfocusCurrentApplication(); // no app should have focus at this point

144+ root.applicationManager.unfocusCurrentApplication(); // no app should have focus at this point

169 }

145 }

170

146

171 function focusNext() {

147 function focusNext() {

172− ApplicationManager.unfocusCurrentApplication();

173 for (var i = 0; i < appRepeater.count; i++) {

148 for (var i = 0; i < appRepeater.count; i++) {

174 var appDelegate = appRepeater.itemAt(i);

149 var appDelegate = appRepeater.itemAt(i);

175 if (appDelegate && !appDelegate.minimized) {

150 if (appDelegate && !appDelegate.minimized) {

176− ApplicationManager.focusApplication(appDelegate.appId);

151+ appDelegate.focus = true;

177 return;

152 return;

178 }

153 }

179 }

154 }

@@ -182,15 +157,9 @@ AbstractStage {

182

157

183 Connections {

158 Connections {

184 target: PanelState

159 target: PanelState

185− onClose: {

160+ onClose: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }

186− ApplicationManager.stopApplication(ApplicationManager.focusedApplicationId)

187− }

188− onMinimize: priv.focusedAppDelegate && priv.focusedAppDelegate.minimize();

161+ onMinimize: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.minimize(); } }

189− onMaximize: priv.focusedAppDelegate // don't restore minimized apps when double clicking the panel

190− && priv.focusedAppDelegate.restoreFromMaximized();

162+ onMaximize: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.restoreFromMaximized(); } }

191− onFocusMaximizedApp: if (priv.foregroundMaximizedAppIndex != -1) {

192− ApplicationManager.focusApplication(appRepeater.itemAt(priv.foregroundMaximizedAppIndex).appId);

193− }

194 }

163 }

195

164

196 Binding {

165 Binding {

@@ -227,6 +196,26 @@ AbstractStage {

227 PanelState.dropShadow = false;

196 PanelState.dropShadow = false;

228 }

197 }

229

198

199+ Instantiator {

200+ model: root.applicationManager

201+ delegate: Binding {

202+ target: model.application

203+ property: "requestedState"

204+

205+ // TODO: figure out some lifecycle policy, like suspending minimized apps

206+ // if running on a tablet or something.

207+ // TODO: If the device has a dozen suspended apps because it was running

208+ // in staged mode, when it switches to Windowed mode it will suddenly

209+ // resume all those apps at once. We might want to avoid that.

210+ value: ApplicationInfoInterface.RequestedRunning // Always running for now

211+ }

212+ }

213+

214+ Binding {

215+ target: MirFocusController

216+ property: "focusedSurface"

217+ value: priv.focusedAppDelegate ? priv.focusedAppDelegate.surface : null

218+ }

230

219

231 FocusScope {

220 FocusScope {

232 id: appContainer

221 id: appContainer

@@ -244,18 +233,23 @@ AbstractStage {

244

233

245 Repeater {

234 Repeater {

246 id: appRepeater

235 id: appRepeater

247− model: ApplicationManager

236+ model: topLevelSurfaceList

248 objectName: "appRepeater"

237 objectName: "appRepeater"

249

238

250 delegate: FocusScope {

239 delegate: FocusScope {

251 id: appDelegate

240 id: appDelegate

252− objectName: "appDelegate_" + appId

241+ objectName: "appDelegate_" + model.id

253 // z might be overriden in some cases by effects, but we need z ordering

242 // z might be overriden in some cases by effects, but we need z ordering

254 // to calculate occlusion detection

243 // to calculate occlusion detection

255− property int normalZ: ApplicationManager.count - index

244+ property int normalZ: topLevelSurfaceList.count - index

256 z: normalZ

245 z: normalZ

246+ onZChanged: {

247+ if (visuallyMaximized) {

248+ priv.updateForegroundMaximizedApp();

249+ }

250+ }

257 y: PanelState.panelHeight

251 y: PanelState.panelHeight

258− focus: appId === priv.focusedAppId

252+

259 width: decoratedWindow.width

253 width: decoratedWindow.width

260 height: decoratedWindow.height

254 height: decoratedWindow.height

261 property int requestedWidth: -1

255 property int requestedWidth: -1

@@ -280,16 +274,51 @@ AbstractStage {

280 readonly property alias minimized: appDelegatePrivate.minimized

274 readonly property alias minimized: appDelegatePrivate.minimized

281 readonly property alias fullscreen: decoratedWindow.fullscreen

275 readonly property alias fullscreen: decoratedWindow.fullscreen

282

276

283− readonly property string appId: model.appId

277+ readonly property var application: model.application

284 property bool animationsEnabled: true

278 property bool animationsEnabled: true

285 property alias title: decoratedWindow.title

279 property alias title: decoratedWindow.title

286− readonly property string appName: model.name

280+ readonly property string appName: model.application ? model.application.name : ""

287 property bool visuallyMaximized: false

281 property bool visuallyMaximized: false

288 property bool visuallyMinimized: false

282 property bool visuallyMinimized: false

289

283

284+ readonly property var surface: model.surface

285+

286+ Connections {

287+ target: model.surface

288+ onFocusRequested: {

289+ if (spread.state == "altTab") {

290+ spread.cancel();

291+ }

292+ appDelegate.restore();

293+ }

294+ }

295+

290 onFocusChanged: {

296 onFocusChanged: {

291− if (focus && ApplicationManager.focusedApplicationId !== appId) {

297+ if (focus) {

292− ApplicationManager.focusApplication(appId);

298+ priv.focusedAppDelegate = appDelegate;

299+ topLevelSurfaceList.move(model.id, 0);

300+ }

301+ }

302+ Component.onCompleted: {

303+ // a top level window is always the focused one when it first appears, unfocusing

304+ // any preexisting one

305+ if (index == 0) {

306+ focus = true;

307+ }

308+ }

309+ Component.onDestruction: {

310+ if (focus) {

311+ // focus some other window

312+ for (var i = 0; i < appRepeater.count; i++) {

313+ var appDelegate = appRepeater.itemAt(i);

314+ if (appDelegate && !appDelegate.minimized && i != index) {

315+ appDelegate.focus = true;

316+ return;

317+ }

318+ }

319+ }

320+ if (visuallyMaximized) {

321+ priv.updateForegroundMaximizedApp();

293 }

322 }

294 }

323 }

295

324

@@ -301,15 +330,12 @@ AbstractStage {

301 decoratedWindow.fullscreen ||

330 decoratedWindow.fullscreen ||

302 (spread.state == "altTab" && index === spread.highlightedIndex)

331 (spread.state == "altTab" && index === spread.highlightedIndex)

303

332

304− Binding {

333+ function close() {

305− target: ApplicationManager.get(index)

334+ model.surface.close();

306− property: "requestedState"

335+ // TODO: Should we brute force and stop the application if it doesn't quit

307− // TODO: figure out some lifecycle policy, like suspending minimized apps

336+ // after having its last window closed?

308− // if running on a tablet or something.

337+ // TODO: Destroy the surface if the application doesn't comply after a given

309− // TODO: If the device has a dozen suspended apps because it was running

338+ // amount of time.

310− // in staged mode, when it switches to Windowed mode it will suddenly

311− // resume all those apps at once. We might want to avoid that.

312− value: ApplicationInfoInterface.RequestedRunning // Always running for now

313 }

339 }

314

340

315 function maximize(animated) {

341 function maximize(animated) {

@@ -351,7 +377,8 @@ AbstractStage {

351 maximizeLeft();

377 maximizeLeft();

352 else if (maximizedRight)

378 else if (maximizedRight)

353 maximizeRight();

379 maximizeRight();

354− ApplicationManager.focusApplication(appId);

380+

381+ focus = true;

355 }

382 }

356

383

357 function playFocusAnimation() {

384 function playFocusAnimation() {

@@ -486,7 +513,7 @@ AbstractStage {

486 id: previewBinding

513 id: previewBinding

487 target: appDelegate

514 target: appDelegate

488 property: "z"

515 property: "z"

489− value: ApplicationManager.count + 1

516+ value: topLevelSurfaceList.count + 1

490 when: index == spread.highlightedIndex && spread.ready

517 when: index == spread.highlightedIndex && spread.ready

491 }

518 }

492

519

@@ -497,12 +524,12 @@ AbstractStage {

497 minWidth: units.gu(10)

524 minWidth: units.gu(10)

498 minHeight: units.gu(10)

525 minHeight: units.gu(10)

499 borderThickness: units.gu(2)

526 borderThickness: units.gu(2)

500− windowId: model.appId // FIXME: Change this to point to windowId once we have such a thing

527+ windowId: model.application.appId // FIXME: Change this to point to windowId once we have such a thing

501 screenWidth: appContainer.width

528 screenWidth: appContainer.width

502 screenHeight: appContainer.height

529 screenHeight: appContainer.height

503 leftMargin: root.leftMargin

530 leftMargin: root.leftMargin

504

531

505− onPressed: { ApplicationManager.focusApplication(model.appId) }

532+ onPressed: { appDelegate.focus = true; }

506

533

507 Component.onCompleted: {

534 Component.onCompleted: {

508 loadWindowState();

535 loadWindowState();

@@ -529,24 +556,25 @@ AbstractStage {

529 objectName: "decoratedWindow"

556 objectName: "decoratedWindow"

530 anchors.left: appDelegate.left

557 anchors.left: appDelegate.left

531 anchors.top: appDelegate.top

558 anchors.top: appDelegate.top

532− application: ApplicationManager.get(index)

559+ application: model.application

533− active: ApplicationManager.focusedApplicationId === model.appId

560+ surface: model.surface

561+ active: appDelegate.focus

534 focus: true

562 focus: true

535

563

536 requestedWidth: appDelegate.requestedWidth

564 requestedWidth: appDelegate.requestedWidth

537 requestedHeight: appDelegate.requestedHeight

565 requestedHeight: appDelegate.requestedHeight

538

566

539− onClose: ApplicationManager.stopApplication(model.appId)

567+ onClose: { appDelegate.close(); }

540 onMaximize: appDelegate.maximized || appDelegate.maximizedLeft || appDelegate.maximizedRight

568 onMaximize: appDelegate.maximized || appDelegate.maximizedLeft || appDelegate.maximizedRight

541 ? appDelegate.restoreFromMaximized() : appDelegate.maximize()

569 ? appDelegate.restoreFromMaximized() : appDelegate.maximize()

542 onMinimize: appDelegate.minimize()

570 onMinimize: appDelegate.minimize()

543− onDecorationPressed: { ApplicationManager.focusApplication(model.appId) }

571+ onDecorationPressed: { appDelegate.focus = true; }

544 }

572 }

545

573

546 WindowedFullscreenPolicy {

574 WindowedFullscreenPolicy {

547 id: fullscreenPolicy

575 id: fullscreenPolicy

548 active: true

576 active: true

549− application: decoratedWindow.application

577+ surface: model.surface

550 }

578 }

551 }

579 }

552 }

580 }

qml/Stages/PhoneStage.qml+124−84

@@ -26,7 +26,6 @@ import "../Components"

26AbstractStage {

27 id: root

29− property QtObject applicationManager: ApplicationManager

30 property bool focusFirstApp: true // If false, focused app will appear on right edge like other apps

29 property bool focusFirstApp: true // If false, focused app will appear on right edge like other apps

31 property bool altTabEnabled: true

30 property bool altTabEnabled: true

32 property real startScale: 1.1

31 property real startScale: 1.1

@@ -107,9 +106,7 @@ AbstractStage {

107 }

106 }

108 }

107 }

109

108

110− mainApp: applicationManager.focusedApplicationId

109+ mainApp: priv.focusedAppDelegate ? priv.focusedAppDelegate.application : null

111− ? applicationManager.findApplication(applicationManager.focusedApplicationId)

112− : null

113

110

114 orientationChangesEnabled: priv.focusedAppOrientationChangesEnabled

111 orientationChangesEnabled: priv.focusedAppOrientationChangesEnabled

115 && !priv.focusedAppDelegateIsDislocated

112 && !priv.focusedAppDelegateIsDislocated

@@ -158,72 +155,27 @@ AbstractStage {

158 onTriggered: { root.beingResized = false; }

155 onTriggered: { root.beingResized = false; }

159 }

156 }

160

157

161− Connections {

162− target: applicationManager

163−

164− onFocusRequested: {

165− if (spreadView.phase > 0) {

166− spreadView.snapTo(priv.indexOf(appId));

167− } else {

168− applicationManager.focusApplication(appId);

169− }

170− }

171−

172− onApplicationAdded: {

173− if (spreadView.phase == 2) {

174− spreadView.snapTo(applicationManager.count - 1);

175− } else {

176− spreadView.phase = 0;

177− spreadView.contentX = -spreadView.shift;

178− applicationManager.focusApplication(appId);

179− }

180− }

181−

182− onApplicationRemoved: {

183− // Unless we're closing the app ourselves in the spread,

184− // lets make sure the spread doesn't mess up by the changing app list.

185− if (spreadView.closingIndex == -1) {

186− spreadView.phase = 0;

187− spreadView.contentX = -spreadView.shift;

188− focusTopMostApp();

189− }

190− }

191−

192− function focusTopMostApp() {

193− if (applicationManager.count > 0) {

194− var topmostApp = applicationManager.get(0);

195− applicationManager.focusApplication(topmostApp.appId);

196− }

197− }

198− }

199−

200 QtObject {

158 QtObject {

201 id: priv

159 id: priv

202

160

203− property string focusedAppId: root.applicationManager.focusedApplicationId

204 property bool focusedAppOrientationChangesEnabled: false

161 property bool focusedAppOrientationChangesEnabled: false

205 readonly property int firstSpreadIndex: root.focusFirstApp ? 1 : 0

162 readonly property int firstSpreadIndex: root.focusFirstApp ? 1 : 0

206− readonly property var focusedAppDelegate: {

163+ property var focusedAppDelegate

207− var index = indexOf(focusedAppId);

164+ // NB! This may differ from applicationManager.focusedApplicationId if focusedAppDelegate

208− return index >= 0 && index < spreadRepeater.count ? spreadRepeater.itemAt(index) : null

165+ // contains a screenshot instead of a surface.

209− }

166+ property string focusedAppId: focusedAppDelegate ? focusedAppDelegate.application.appId : ""

210

167

211 property real oldInverseProgress: 0

168 property real oldInverseProgress: 0

212 property bool animateX: false

169 property bool animateX: false

213 property int highlightIndex: 0

170 property int highlightIndex: 0

214

171

215− onFocusedAppDelegateChanged: {

216− if (focusedAppDelegate) {

217− focusedAppDelegate.focus = true;

218− }

219− }

220−

221− property bool focusedAppDelegateIsDislocated: focusedAppDelegate &&

172+ property bool focusedAppDelegateIsDislocated: focusedAppDelegate ?

222 (focusedAppDelegate.x !== 0 || focusedAppDelegate.xBehavior.running)

173 (focusedAppDelegate.x !== 0 || focusedAppDelegate.xBehavior.running)

174+ : false

223

175

224 function indexOf(appId) {

176 function indexOf(appId) {

225− for (var i = 0; i < root.applicationManager.count; i++) {

177+ for (var i = 0; i < spreadRepeater.count; i++) {

226− if (root.applicationManager.get(i).appId == appId) {

178+ if (spreadRepeater.itemAt(i).application.appId == appId) {

227 return i;

179 return i;

228 }

180 }

229 }

181 }

@@ -237,8 +189,8 @@ AbstractStage {

237 function reset() {

189 function reset() {

238 // The app that's about to go to foreground has to be focused, otherwise

190 // The app that's about to go to foreground has to be focused, otherwise

239 // it would leave us in an inconsistent state.

191 // it would leave us in an inconsistent state.

240− if (!root.applicationManager.focusedApplicationId && root.applicationManager.count > 0) {

192+ if (!MirFocusController.focusedSurface && spreadRepeater.count > 0) {

241− root.applicationManager.focusApplication(root.applicationManager.get(0).appId);

193+ spreadRepeater.itemAt(0).focus = true;

242 }

194 }

243

195

244 spreadView.selectedIndex = -1;

196 spreadView.selectedIndex = -1;

@@ -258,6 +210,25 @@ AbstractStage {

258 }

210 }

259 }

211 }

260

212

213+ Instantiator {

214+ model: root.applicationManager

215+ delegate: Binding {

216+ readonly property bool isDash: model.application ? model.application.appId == "unity8-dash" : false

217+ target: model.application

218+ property: "requestedState"

219+ value: (isDash && root.keepDashRunning)

220+ || (!root.suspended && model.application && priv.focusedAppId === model.application.appId)

221+ ? ApplicationInfoInterface.RequestedRunning

222+ : ApplicationInfoInterface.RequestedSuspended

223+ }

224+ }

225+

226+ Binding {

227+ target: MirFocusController

228+ property: "focusedSurface"

229+ value: priv.focusedAppDelegate ? priv.focusedAppDelegate.surface : null

230+ }

231+

261 Flickable {

232 Flickable {

262 id: spreadView

233 id: spreadView

263 objectName: "spreadView"

234 objectName: "spreadView"

@@ -308,13 +279,37 @@ AbstractStage {

308 // rely on having Flickable.contentX keeping an out-of-bounds value when it's set programatically

279 // rely on having Flickable.contentX keeping an out-of-bounds value when it's set programatically

309 // (as opposed to having contentX reaching an out-of-bounds value through dragging, which will trigger

280 // (as opposed to having contentX reaching an out-of-bounds value through dragging, which will trigger

310 // the Flickable.boundsBehavior upon release).

281 // the Flickable.boundsBehavior upon release).

282+ onContentXChanged: {

283+ if (!undoContentXReset()) {

311− onContentXChanged: { forceItToRemainStillIfBeingResized(); }

284+ forceItToRemainStillIfBeingResized();

285+ }

286+ }

312 onShiftChanged: { forceItToRemainStillIfBeingResized(); }

287 onShiftChanged: { forceItToRemainStillIfBeingResized(); }

313 function forceItToRemainStillIfBeingResized() {

288 function forceItToRemainStillIfBeingResized() {

314 if (root.beingResized && contentX != -spreadView.shift) {

289 if (root.beingResized && contentX != -spreadView.shift) {

315 contentX = -spreadView.shift;

290 contentX = -spreadView.shift;

316 }

291 }

317 }

292 }

293+ function undoContentXReset() {

294+ if (contentWidth === -1) {

295+ contentWidthOnLastContentXChange = contentWidth;

296+ lastContentX = contentX;

297+ return false;

298+ }

299+

300+ if (contentWidth != contentWidthOnLastContentXChange

301+ && lastContentX == -shift && contentX == 0) {

302+ // Flickable is resetting contentX because contentWidth has changed. Undo it.

303+ contentX = -shift;

304+ return true;

305+ }

306+

307+ contentWidthOnLastContentXChange = contentWidth;

308+ lastContentX = contentX;

309+ return false;

310+ }

311+ property real contentWidthOnLastContentXChange: -1

312+ property real lastContentX: 0

318

313

319 Behavior on contentX {

314 Behavior on contentX {

320 enabled: root.altTabPressed

315 enabled: root.altTabPressed

@@ -377,7 +372,7 @@ AbstractStage {

377 snapAnimation.start();

372 snapAnimation.start();

378 return;

373 return;

379 }

374 }

380− if (root.applicationManager.count <= index) {

375+ if (topLevelSurfaceList.count <= index) {

381 // In case we're trying to snap to some non existing app, lets snap back to the first one

376 // In case we're trying to snap to some non existing app, lets snap back to the first one

382 index = 0;

377 index = 0;

383 }

378 }

@@ -414,7 +409,8 @@ AbstractStage {

414 ScriptAction {

409 ScriptAction {

415 script: {

410 script: {

416 if (spreadView.selectedIndex >= 0) {

411 if (spreadView.selectedIndex >= 0) {

417− root.applicationManager.focusApplication(root.applicationManager.get(spreadView.selectedIndex).appId);

412+ var delegate = spreadRepeater.itemAt(spreadView.selectedIndex)

413+ delegate.focus = true;

418

414

419 spreadView.selectedIndex = -1;

415 spreadView.selectedIndex = -1;

420 spreadView.phase = 0;

416 spreadView.phase = 0;

@@ -429,7 +425,7 @@ AbstractStage {

429 // This width controls how much the spread can be flicked left/right. It's composed of:

425 // This width controls how much the spread can be flicked left/right. It's composed of:

430 // tileDistance * app count (with a minimum of 3 apps, in order to also allow moving 1 and 2 apps a bit)

426 // tileDistance * app count (with a minimum of 3 apps, in order to also allow moving 1 and 2 apps a bit)

431 // + some constant value (still scales with the screen width) which looks good and somewhat fills the screen

427 // + some constant value (still scales with the screen width) which looks good and somewhat fills the screen

432− width: Math.max(3, root.applicationManager.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5

428+ width: Math.max(3, topLevelSurfaceList.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5

433 height: parent.height

429 height: parent.height

434 Behavior on width {

430 Behavior on width {

435 enabled: spreadView.closingIndex >= 0

431 enabled: spreadView.closingIndex >= 0

@@ -452,10 +448,33 @@ AbstractStage {

452 Repeater {

448 Repeater {

453 id: spreadRepeater

449 id: spreadRepeater

454 objectName: "spreadRepeater"

450 objectName: "spreadRepeater"

455− model: root.applicationManager

451+ model: topLevelSurfaceList

452+

453+ onItemAdded: {

454+ if (spreadView.phase == 2) {

455+ spreadView.snapTo(spreadRepeater.count - 1);

456+ }

457+ }

458+

459+ onItemRemoved: {

460+ // Unless we're closing the app ourselves in the spread,

461+ // lets make sure the spread doesn't mess up by the changing app list.

462+ if (spreadView.closingIndex == -1) {

463+ spreadView.phase = 0;

464+ spreadView.contentX = -spreadView.shift;

465+ focusTopMostApp();

466+ }

467+ }

468+ function focusTopMostApp() {

469+ if (spreadRepeater.count > 0) {

470+ var topmostDelegate = spreadRepeater.itemAt(0);

471+ topmostDelegate.focus = true;

472+ }

473+ }

474+

456 delegate: TransformedSpreadDelegate {

475 delegate: TransformedSpreadDelegate {

457 id: appDelegate

476 id: appDelegate

458− objectName: "appDelegate" + index

477+ objectName: "spreadDelegate_" + model.id

459 startAngle: 45

478 startAngle: 45

460 endAngle: 5

479 endAngle: 5

461 startScale: root.startScale

480 startScale: root.startScale

@@ -467,28 +486,44 @@ AbstractStage {

467 selected: spreadView.selectedIndex == index

486 selected: spreadView.selectedIndex == index

468 otherSelected: spreadView.selectedIndex >= 0 && !selected

487 otherSelected: spreadView.selectedIndex >= 0 && !selected

469 interactive: !spreadView.interactive && spreadView.phase === 0

488 interactive: !spreadView.interactive && spreadView.phase === 0

470− && priv.fullyShowingFocusedApp && root.interactive && isFocused

489+ && priv.fullyShowingFocusedApp && root.interactive && focus

471 swipeToCloseEnabled: spreadView.interactive && root.interactive && !snapAnimation.running

490 swipeToCloseEnabled: spreadView.interactive && root.interactive && !snapAnimation.running

472 maximizedAppTopMargin: root.maximizedAppTopMargin

491 maximizedAppTopMargin: root.maximizedAppTopMargin

473 dropShadow: spreadView.active || priv.focusedAppDelegateIsDislocated

492 dropShadow: spreadView.active || priv.focusedAppDelegateIsDislocated

474 focusFirstApp: root.focusFirstApp

493 focusFirstApp: root.focusFirstApp

475 highlightShown: root.altTabPressed && index === priv.highlightIndex

494 highlightShown: root.altTabPressed && index === priv.highlightIndex

476

495

477− readonly property bool isDash: model.appId == "unity8-dash"

496+ readonly property bool isDash: model.application.appId == "unity8-dash"

478

497

479− Binding {

498+ Component.onCompleted: {

480− target: appDelegate.application

499+ // a top level window is always the focused one when it first appears, unfocusing

481− property: "exemptFromLifecycle"

500+ // any preexisting one

482− value: !model.isTouchApp || isExemptFromLifecycle(model.appId)

501+ if (model.index == 0) {

502+ focus = true;

503+ }

504+ }

505+

506+ onFocusChanged: {

507+ if (focus) {

508+ priv.focusedAppDelegate = appDelegate;

509+ topLevelSurfaceList.move(model.id, 0);

510+ }

511+ }

512+ Connections {

513+ target: model.surface

514+ onFocusRequested: {

515+ if (spreadView.phase > 0) {

516+ spreadView.snapTo(model.index);

517+ } else {

518+ appDelegate.focus = true;

519+ }

520+ }

483 }

521 }

484

522

485 Binding {

523 Binding {

486 target: appDelegate.application

524 target: appDelegate.application

487− property: "requestedState"

525+ property: "exemptFromLifecycle"

488− value: (isDash && root.keepDashRunning)

526+ value: !model.isTouchApp || isExemptFromLifecycle(model.appId)

489− || (!root.suspended && appDelegate.focus)

490− ? ApplicationInfoInterface.RequestedRunning

491− : ApplicationInfoInterface.RequestedSuspended

492 }

527 }

493

528

494 z: isDash && !spreadView.active ? -1 : behavioredIndex

529 z: isDash && !spreadView.active ? -1 : behavioredIndex

@@ -509,7 +544,8 @@ AbstractStage {

509 return spreadView.width + spreadIndex * spreadView.tileDistance;

544 return spreadView.width + spreadIndex * spreadView.tileDistance;

510 }

545 }

511

546

512− application: root.applicationManager.get(index)

547+ application: model.application

548+ surface: model.surface

513 closeable: !isDash

549 closeable: !isDash

514

550

515 property real behavioredIndex: index

551 property real behavioredIndex: index

@@ -593,11 +629,7 @@ AbstractStage {

593

629

594 onClicked: {

630 onClicked: {

595 if (root.altTabEnabled && spreadView.phase == 2) {

631 if (root.altTabEnabled && spreadView.phase == 2) {

596− if (root.applicationManager.focusedApplicationId == root.applicationManager.get(index).appId) {

597− spreadView.snapTo(index);

632+ spreadView.snapTo(index);

598− } else {

599− root.applicationManager.requestFocusApplication(root.applicationManager.get(index).appId);

600− }

601 }

633 }

602 }

634 }

603

635

@@ -611,7 +643,15 @@ AbstractStage {

611

643

612 onClosed: {

644 onClosed: {

613 spreadView.closingIndex = index;

645 spreadView.closingIndex = index;

646+ if (appDelegate.surface) {

647+ appDelegate.surface.close();

648+ } else if (appDelegate.application) {

614− root.applicationManager.stopApplication(root.applicationManager.get(index).appId);

649+ root.applicationManager.stopApplication(appDelegate.application.appId);

650+ } else {

651+ // should never happen

652+ console.warn("Can't close topLevelSurfaceList entry as it has neither"

653+ + " a surface nor an application");

654+ }

615 }

655 }

616

656

617 Binding {

657 Binding {

@@ -637,7 +677,7 @@ AbstractStage {

637 onStageAboutToBeUnloaded: fullscreenPolicy.active = false

677 onStageAboutToBeUnloaded: fullscreenPolicy.active = false

638 }

678 }

639 }

679 }

640− }

680+ } // Repeater {

641 }

681 }

642 }

682 }

643

683

qml/Stages/PromptSurfaceAnimations.qmlnew file+77

@@ -0,0 +1,77 @@

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+

17+import QtQuick 2.4

18+import Ubuntu.Components 1.3

19+

20+StateGroup {

21+ id: root

22+ property var container

23+ property var surfaceItem

24+

25+ states: [

26+ State {

27+ name: "blank"

28+ when: !root.surfaceItem.surface

29+ },

30+ State {

31+ name: "ready"

32+ when: root.surfaceItem.surface && root.surfaceItem.live

33+ },

34+ State {

35+ name: "zombie"

36+ when: root.surfaceItem.surface && !root.surfaceItem.live

37+ }

38+ ]

39+ transitions: [

40+ Transition {

41+ from: "*"; to: "zombie"

42+ SequentialAnimation {

43+ // clip so we don't go out of parent's bounds during spread

44+ PropertyAction { target: root.container.parent; property: "clip"; value: true }

45+ UbuntuNumberAnimation { target: root.surfaceItem; property: "y"; to: root.container.height

46+ duration: UbuntuAnimation.BriskDuration }

47+ PropertyAction { target: root.surfaceItem; property: "visible"; value: false }

48+ PropertyAction { target: container.parent; property: "clip"; value: false }

49+ ScriptAction { script: {

50+ root.surfaceItem.surface = null;

51+ } }

52+ }

53+ },

54+ Transition {

55+ from: "*"; to: "ready"

56+ SequentialAnimation {

57+ // clip so we don't go out of parent's bounds during spread

58+ PropertyAction { target: root.container.parent; property: "clip"; value: true }

59+ ScriptAction { script: {

60+ root.surfaceItem.y = root.container.height;

61+ root.surfaceItem.visible = true;

62+ } }

63+ UbuntuNumberAnimation {

64+ target: root.surfaceItem; property: "y"; to: 0

65+ duration: UbuntuAnimation.BriskDuration

66+ }

67+ PropertyAction { target: container.parent; property: "clip"; value: false }

68+ }

69+ },

70+ Transition {

71+ from: "*"; to: "blank"

72+ ScriptAction { script: {

73+ root.surfaceItem.visible = false;

74+ } }

75+ }

76+ ]

77+}

qml/Stages/SessionContainer.qmldeleted−180

@@ -1,180 +0,0 @@

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−

17−import QtQuick 2.4

18−import "Animations"

19−

20−FocusScope {

21− id: root

22− objectName: "sessionContainer"

23− implicitWidth: _surfaceContainer.implicitWidth

24− implicitHeight: _surfaceContainer.implicitHeight

25− property QtObject session

26− readonly property var childSessions: session ? session.childSessions : null

27− readonly property alias surface: _surfaceContainer.surface

28− property alias interactive: _surfaceContainer.interactive

29− property alias surfaceOrientationAngle: _surfaceContainer.surfaceOrientationAngle

30− property alias resizeSurface: _surfaceContainer.resizeSurface

31−

32− property int requestedWidth: -1

33− property int requestedHeight: -1

34−

35− readonly property alias surfaceContainer: _surfaceContainer

36− SurfaceContainer {

37− id: _surfaceContainer

38− requestedWidth: root.requestedWidth

39− requestedHeight: root.requestedHeight

40− surface: session ? session.lastSurface : null

41− }

42−

43− // SurfaceContainer size drives SessionContainer size

44− Binding {

45− target: root; property: "width"; value: _surfaceContainer.width

46− when: root.requestedWidth >= 0

47− }

48− Binding {

49− target: root; property: "height"; value: _surfaceContainer.height

50− when: root.requestedHeight >= 0

51− }

52−

53− // SessionContainer size drives SurfaceContainer size

54− Binding {

55− target: _surfaceContainer; property: "width"; value: root.width

56− when: root.requestedWidth < 0

57− }

58− Binding {

59− target: _surfaceContainer; property: "height"; value: root.height

60− when: root.requestedHeight < 0

61− }

62−

63− Repeater {

64− id: childSessionsRepeater

65− model: root.childSessions

66−

67− delegate: Loader {

68− objectName: "childDelegate" + index

69− anchors.fill: surfaceContainer

70−

71− // Only way to do recursive qml items.

72− source: Qt.resolvedUrl("SessionContainer.qml")

73−

74− z: index

75−

76− // Since a Loader is a FocusScope, propagate its focus to the loaded Item

77− Binding {

78− target: item; when: item

79− property: "focus"; value: focus

80− }

81−

82− Binding {

83− target: item; when: item

84− property: "interactive"; value: index == (childSessionsRepeater.count - 1) && root.interactive

85− }

86−

87− Binding {

88− target: item; when: item

89− property: "session"; value: modelData

90− }

91−

92− Binding {

93− target: item; when: item

94− property: "width"; value: root.width

95− }

96−

97− Binding {

98− target: item; when: item

99− property: "height"; value: root.height

100− }

101− }

102− }

103−

104− states: [

105− State {

106− name: "rootSession"

107− when: root.session && !root.session.parentSession

108− },

109−

110− State {

111− name: "childSession"

112− when: root.session && root.session.parentSession !== null && root.session.live

113− && !root.session.lastSurface

114− },

115−

116− State {

117− name: "childSessionReady"

118− when: root.session && root.session.parentSession !== null && root.session.live

119− && root.session.lastSurface !== null

120− },

121−

122− State {

123− name: "childSessionZombie"

124− when: root.session && root.session.parentSession !== null && !root.session.live

125− }

126− ]

127−

128− transitions: [

129− Transition {

130− to: "childSessionReady"

131− ScriptAction { script: { if (!surfaceContainer.hadSurface) { animateIn(swipeFromBottom); } } }

132− },

133− Transition {

134− to: "childSessionZombie"

135− ScriptAction { script: { animateOut(); } }

136− }

137− ]

138−

139− function animateIn(component) {

140− var animation = component.createObject(root, { "container": root, });

141− animation.start();

142−

143− var tmp = d.animations;

144− tmp.push(animation);

145− d.animations = tmp;

146− }

147−

148− function animateOut() {

149− if (d.animations.length > 0) {

150− var tmp = d.animations;

151− var popped = tmp.pop();

152− popped.completed.connect(function() { root.session.release(); } );

153− popped.end();

154− d.animations = tmp;

155− } else {

156− root.session.release();

157− }

158− }

159−

160− Component {

161− id: swipeFromBottom

162− SwipeFromBottomAnimation {}

163− }

164−

165− QtObject {

166− id: d

167− property var animations: []

168−

169− property var focusedChild: {

170− if (childSessionsRepeater.count == 0) {

171− return _surfaceContainer;

172− } else {

173− return childSessionsRepeater.itemAt(childSessionsRepeater.count - 1);

174− }

175− }

176− onFocusedChildChanged: {

177− focusedChild.focus = true;

178− }

179− }

180−}

qml/Stages/SpreadDelegate.qml+4−3

@@ -1,5 +1,5 @@

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

@@ -45,6 +45,7 @@ FocusScope {

45 property alias swipeToCloseEnabled: dragArea.enabled

46 property bool closeable

47 property alias application: appWindow.application

48+ property alias surface: appWindow.surface

48 property int shellOrientationAngle

49 property int shellOrientationAngle

49 property int shellOrientation

50 property int shellOrientation

50 property QtObject orientations

51 property QtObject orientations

@@ -250,7 +251,7 @@ FocusScope {

250 }

251 }

251 PropertyChanges {

252 PropertyChanges {

252 target: appWindow

253 target: appWindow

253− surfaceOrientationAngle: orientationAngle

254+ surfaceOrientationAngle: appWindowWithShadow.orientationAngle

254 }

255 }

255 },

256 },

256 State {

257 State {

@@ -292,7 +293,7 @@ FocusScope {

292

293

293 ApplicationWindow {

294 ApplicationWindow {

294 id: appWindow

295 id: appWindow

295− objectName: application ? "appWindow_" + application.appId : "appWindow_null"

296+ objectName: "appWindow"

296 focus: true

297 focus: true

297 anchors {

298 anchors {

298 fill: parent

299 fill: parent

qml/Stages/SurfaceContainer.qml+97−40

@@ -1,5 +1,5 @@

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

@@ -24,21 +24,22 @@ FocusScope {

24 id: root

25 objectName: "surfaceContainer"

27+ // Must be set from outside

27 property var surface: null

28 property var surface: null

28− property bool hadSurface: false

29− property bool interactive

30− property int surfaceOrientationAngle: 0

31− property string name: surface ? surface.name : ""

32− property bool resizeSurface: true

30+ // Might be changed from outside

34 property int requestedWidth: -1

31 property int requestedWidth: -1

35 property int requestedHeight: -1

32 property int requestedHeight: -1

33+ property bool interactive

34+ property int surfaceOrientationAngle: 0

35+ property bool resizeSurface: true

36+ property bool inPromptSession: false

37 onSurfaceChanged: {

38 onSurfaceChanged: {

38− if (surface) {

39+ // not a binding because in some cases

39− surfaceItem.surface = surface;

40+ // we remove the surface from the surfaceItem programatically,

40− root.hadSurface = false;

41+ // even though root.surface is still !null

41− }

42+ surfaceItem.surface = surface;

42 }

43 }

44 InputWatcher {

45 InputWatcher {

@@ -83,11 +84,16 @@ FocusScope {

83 }

84 }

85 enabled: root.interactive

86 enabled: root.interactive

86− focus: true

87 antialiasing: !root.interactive

88 orientationAngle: root.surfaceOrientationAngle

89 }

91+ TouchGate {

92+ targetItem: surfaceItem

93+ anchors.fill: root

94+ enabled: surfaceItem.enabled

95+ }

96+

91 // MirSurface size drives SurfaceContainer size

97 // MirSurface size drives SurfaceContainer size

92 Binding {

98 Binding {

93 target: surfaceItem; property: "width"; value: root.surface ? root.surface.size.width : 0

99 target: surfaceItem; property: "width"; value: root.surface ? root.surface.size.width : 0

@@ -116,39 +122,90 @@ FocusScope {

116 when: root.requestedHeight < 0

122 when: root.requestedHeight < 0

117 }

123 }

118

124

125+ Repeater {

126+ id: childSurfacesRepeater

127+ objectName: "childSurfacesRepeater"

128+ model: root.surface ? root.surface.promptSurfaceList : null

119

129

120− TouchGate {

130+ delegate: Loader {

121− objectName: "touchGate-"+name

131+ objectName: "childDelegate" + index

122− targetItem: surfaceItem

123− anchors.fill: root

132+ anchors.fill: root

124− enabled: surfaceItem.enabled

133+

134+ // Only way to do recursive qml items.

135+ source: Qt.resolvedUrl("SurfaceContainer.qml")

136+

137+ z: index

138+

139+ // Since a Loader is a FocusScope, propagate its focus to the loaded Item

140+ Binding {

141+ target: item; when: item

142+ property: "focus"; value: focus

143+ }

144+

145+ Binding {

146+ target: item; when: item

147+ property: "interactive"; value: index == (childSurfacesRepeater.count - 1) && root.interactive

148+ }

149+

150+ Binding {

151+ target: item; when: item

152+ property: "surface"; value: model.surface

153+ }

154+

155+ Binding {

156+ target: item; when: item

157+ property: "width"; value: root.width

158+ }

159+

160+ Binding {

161+ target: item; when: item

162+ property: "height"; value: root.height

163+ }

164+

165+ Binding {

166+ target: item; when: item

167+ property: "inPromptSession"; value: true

168+ }

169+ }

125 }

170 }

126

171

127− states: [

172+ Loader {

128− State {

173+ id: animationsLoader

129− name: "zombie"

174+ objectName: "animationsLoader"

175+ active: root.surface

176+ source: {

177+ if (root.inPromptSession) {

178+ return "PromptSurfaceAnimations.qml";

179+ } else {

180+ // Let ApplicationWindow do the animations

181+ return "";

182+ }

183+ }

184+ Binding {

185+ target: animationsLoader.item

186+ when: animationsLoader.item

187+ property: "surfaceItem"

130− when: surfaceItem.surface && !surfaceItem.live

188+ value: surfaceItem

189+ }

190+ Binding {

191+ target: animationsLoader.item

192+ when: animationsLoader.item

193+ property: "container"

194+ value: root

131 }

195 }

132− ]

196+ }

133− transitions: [

197+

134− Transition {

198+ QtObject {

135− from: ""; to: "zombie"

199+ id: d

136− SequentialAnimation {

200+ property var focusedChild: {

137− UbuntuNumberAnimation { target: surfaceItem; property: "opacity"; to: 0.0

201+ if (childSurfacesRepeater.count == 0) {

138− duration: UbuntuAnimation.BriskDuration }

202+ return surfaceItem;

139− PropertyAction { target: surfaceItem; property: "visible"; value: false }

203+ } else {

140− ScriptAction { script: {

204+ return childSurfacesRepeater.itemAt(childSurfacesRepeater.count - 1);

141− surfaceItem.surface = null;

142− root.hadSurface = true;

143− } }

144 }

205 }

145− },

146− Transition {

147− from: "zombie"; to: ""

148− ScriptAction { script: {

149− surfaceItem.opacity = 1.0;

150− surfaceItem.visible = true;

151− } }

152 }

206 }

153− ]

207+ onFocusedChildChanged: {

208+ focusedChild.focus = true;

209+ }

210+ }

154}

211}

qml/Stages/TabletStage.qml+281−223

@@ -32,14 +32,15 @@ AbstractStage {

33 // Functions to be called from outside

34 function updateFocusedAppOrientation() {

35− var mainStageAppIndex = priv.indexOf(priv.mainStageAppId);

35+ var mainStageIndex = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);

36− if (mainStageAppIndex >= 0 && mainStageAppIndex < spreadRepeater.count) {

36+

37+ if (priv.mainStageItemId && mainStageIndex >= 0 && mainStageIndex < spreadRepeater.count) {

37− spreadRepeater.itemAt(mainStageAppIndex).matchShellOrientation();

38+ spreadRepeater.itemAt(mainStageIndex).matchShellOrientation();

38 }

39 }

40 for (var i = 0; i < spreadRepeater.count; ++i) {

41 for (var i = 0; i < spreadRepeater.count; ++i) {

42− if (i === mainStageAppIndex) {

43+ if (i === mainStageIndex) {

43 continue;

44 continue;

44 }

45 }

@@ -60,16 +61,14 @@ AbstractStage {

60 }

61 }

62 }

62 function updateFocusedAppOrientationAnimated() {

63 function updateFocusedAppOrientationAnimated() {

63− var mainStageAppIndex = priv.indexOf(priv.mainStageAppId);

64+ var mainStageIndex = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);

64− if (mainStageAppIndex >= 0 && mainStageAppIndex < spreadRepeater.count) {

65+ if (priv.mainStageItemId && mainStageIndex >= 0 && mainStageIndex < spreadRepeater.count) {

65− spreadRepeater.itemAt(mainStageAppIndex).animateToShellOrientation();

66+ spreadRepeater.itemAt(mainStageIndex).animateToShellOrientation();

66 }

67 }

68− if (priv.sideStageAppId) {

69+ var sideStageIndex = root.topLevelSurfaceList.indexForId(priv.sideStageItemId);

69− var sideStageAppIndex = priv.indexOf(priv.sideStageAppId);

70− if (sideStageAppIndex >= 0 && sideStageAppIndex < spreadRepeater.count) {

70+ if (sideStageIndex >= 0 && sideStageIndex < spreadRepeater.count) {

71− spreadRepeater.itemAt(sideStageAppIndex).matchShellOrientation();

71+ spreadRepeater.itemAt(sideStageIndex).matchShellOrientation();

72− }

73 }

72 }

74 }

73 }

@@ -81,11 +80,20 @@ AbstractStage {

82 orientationChangesEnabled: priv.mainAppOrientationChangesEnabled

81 orientationChangesEnabled: priv.mainAppOrientationChangesEnabled

83+ mainApp: {

84+ if (priv.mainStageItemId > 0) {

85+ var index = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);

86+ return root.topLevelSurfaceList.applicationAt(index);

87+ } else {

88+ return null;

89+ }

90+ }

91+

84 supportedOrientations: {

92 supportedOrientations: {

85 if (mainApp) {

93 if (mainApp) {

86 var orientations = mainApp.supportedOrientations;

94 var orientations = mainApp.supportedOrientations;

87 orientations |= Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation;

95 orientations |= Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation;

88− if (priv.sideStageAppId && !spreadView.surfaceDragging) {

96+ if (priv.sideStageItemId && !spreadView.surfaceDragging) {

89 // If we have a sidestage app, support Portrait orientation

97 // If we have a sidestage app, support Portrait orientation

90 // so that it will switch the sidestage app to mainstage on rotate

98 // so that it will switch the sidestage app to mainstage on rotate

91 orientations |= Qt.PortraitOrientation|Qt.InvertedPortraitOrientation;

99 orientations |= Qt.PortraitOrientation|Qt.InvertedPortraitOrientation;

@@ -116,7 +124,7 @@ AbstractStage {

116 if (inverseProgress == 0 && priv.oldInverseProgress > 0) {

124 if (inverseProgress == 0 && priv.oldInverseProgress > 0) {

117 // left edge drag released. Minimum distance is given by design.

125 // left edge drag released. Minimum distance is given by design.

118 if (priv.oldInverseProgress > units.gu(22)) {

126 if (priv.oldInverseProgress > units.gu(22)) {

119− ApplicationManager.requestFocusApplication("unity8-dash");

127+ root.applicationManager.requestFocusApplication("unity8-dash");

120 }

128 }

121 }

129 }

122 priv.oldInverseProgress = inverseProgress;

130 priv.oldInverseProgress = inverseProgress;

@@ -154,17 +162,56 @@ AbstractStage {

154 }

162 }

155 }

163 }

156

164

165+ Connections {

166+ target: root.topLevelSurfaceList

167+ onListChanged: priv.updateMainAndSideStageIndexes()

168+ }

169+

170+ onTopLevelSurfaceListChanged: {

171+ // Initialize their values

172+ priv.updateMainAndSideStageIndexes();

173+ }

174+

157 QtObject {

175 QtObject {

158 id: priv

176 id: priv

159 objectName: "stagesPriv"

177 objectName: "stagesPriv"

160

178

161− property string focusedAppId: ApplicationManager.focusedApplicationId

179+ function updateMainAndSideStageIndexes() {

162− readonly property var focusedAppDelegate: {

180+ var choseMainStage = false;

163− var index = indexOf(focusedAppId);

181+ var choseSideStage = false;

164− return index >= 0 && index < spreadRepeater.count ? spreadRepeater.itemAt(index) : null

182+

183+ if (!root.topLevelSurfaceList)

184+ return;

185+

186+ for (var i = 0; i < root.topLevelSurfaceList.count && (!choseMainStage || !choseSideStage); ++i) {

187+ var spreadDelegate = spreadRepeater.itemAt(i);

188+ if (!spreadView.sideStageHidden && spreadDelegate.stage == ApplicationInfoInterface.SideStage

189+ && !choseSideStage) {

190+ priv.sideStageDelegate = spreadDelegate

191+ priv.sideStageItemId = root.topLevelSurfaceList.idAt(i);

192+ priv.sideStageAppId = root.topLevelSurfaceList.applicationAt(i).appId;

193+ choseSideStage = true;

194+ } else if (!choseMainStage && spreadDelegate.stage == ApplicationInfoInterface.MainStage) {

195+ priv.mainStageDelegate = spreadDelegate;

196+ priv.mainStageItemId = root.topLevelSurfaceList.idAt(i);

197+ priv.mainStageAppId = root.topLevelSurfaceList.applicationAt(i).appId;

198+ choseMainStage = true;

199+ }

200+ }

201+ if (!choseMainStage) {

202+ priv.mainStageDelegate = null;

203+ priv.mainStageItemId = 0;

204+ priv.mainStageAppId = "";

205+ }

206+ if (!choseSideStage) {

207+ priv.sideStageDelegate = null;

208+ priv.sideStageItemId = 0;

209+ priv.sideStageAppId = "";

210+ }

165 }

211 }

166

212

167− property string oldFocusedAppId: ""

213+ property var focusedAppDelegate: null

214+

168 property bool mainAppOrientationChangesEnabled: false

215 property bool mainAppOrientationChangesEnabled: false

169

216

170 property real landscapeHeight: root.orientations.native_ == Qt.LandscapeOrientation ?

217 property real landscapeHeight: root.orientations.native_ == Qt.LandscapeOrientation ?

@@ -173,36 +220,21 @@ AbstractStage {

173 property bool shellIsLandscape: root.shellOrientation === Qt.LandscapeOrientation

220 property bool shellIsLandscape: root.shellOrientation === Qt.LandscapeOrientation

174 || root.shellOrientation === Qt.InvertedLandscapeOrientation

221 || root.shellOrientation === Qt.InvertedLandscapeOrientation

175

222

176− property string mainStageAppId

223+ property var mainStageDelegate: null

177− property string sideStageAppId

224+ property var sideStageDelegate: null

225+

226+ property int mainStageItemId: 0

227+ property int sideStageItemId: 0

178

228

179− // For convenience, keep properties of the first two apps in the model

229+ property string mainStageAppId: ""

180− property string appId0

230+ property string sideStageAppId: ""

181− property string appId1

182

231

183 property int oldInverseProgress: 0

232 property int oldInverseProgress: 0

184

233

185 property int highlightIndex: 0

234 property int highlightIndex: 0

186

235

187− onFocusedAppIdChanged: updateStageApps()

188−

189− onFocusedAppDelegateChanged: {

190− if (focusedAppDelegate) {

191− focusedAppDelegate.focus = true;

192− }

193− }

194−

195 property bool focusedAppDelegateIsDislocated: focusedAppDelegate &&

236 property bool focusedAppDelegateIsDislocated: focusedAppDelegate &&

196 (focusedAppDelegate.dragOffset !== 0 || focusedAppDelegate.xTranslateAnimating)

237 (focusedAppDelegate.dragOffset !== 0 || focusedAppDelegate.xTranslateAnimating)

197− function indexOf(appId) {

198− for (var i = 0; i < ApplicationManager.count; i++) {

199− if (ApplicationManager.get(i).appId == appId) {

200− return i;

201− }

202− }

203− return -1;

204− }

205−

206 function evaluateOneWayFlick(gesturePoints) {

238 function evaluateOneWayFlick(gesturePoints) {

207 // Need to have at least 3 points to recognize it as a flick

239 // Need to have at least 3 points to recognize it as a flick

208 if (gesturePoints.length < 3) {

240 if (gesturePoints.length < 3) {

@@ -231,88 +263,41 @@ AbstractStage {

231 spreadView.contentX = highlightIndex * spreadView.contentWidth / (spreadRepeater.count + 2)

263 spreadView.contentX = highlightIndex * spreadView.contentWidth / (spreadRepeater.count + 2)

232 }

264 }

233

265

234− function getTopApp(stage) {

235− for (var i = 0; i < ApplicationManager.count; i++) {

236− var app = ApplicationManager.get(i)

237− if (app.stage === stage) {

238− return app;

239− }

240− }

241− return null;

242− }

243−

244− function setAppStage(appId, stage, save) {

266+ function setAppStage(appId, stage) {

245− var app = ApplicationManager.findApplication(appId);

267+ var app = root.applicationManager.findApplication(appId);

246 if (app) {

268 if (app) {

247 app.stage = stage;

269 app.stage = stage;

248− if (save) {

249− WindowStateStorage.saveStage(appId, stage);

250− }

251− }

252− }

253−

254− function updateStageApps() {

255− var app = priv.getTopApp(ApplicationInfoInterface.MainStage);

256− priv.mainStageAppId = app ? app.appId : ""

257− root.mainApp = app;

258−

259− if (sideStage.shown) {

260− app = priv.getTopApp(ApplicationInfoInterface.SideStage);

261− priv.sideStageAppId = app ? app.appId : ""

262− } else {

263− priv.sideStageAppId = "";

264 }

270 }

265−

266− appId0 = ApplicationManager.count >= 1 ? ApplicationManager.get(0).appId : "";

267− appId1 = ApplicationManager.count > 1 ? ApplicationManager.get(1).appId : "";

268 }

271 }

269

272

270 readonly property bool sideStageEnabled: root.shellOrientation == Qt.LandscapeOrientation ||

273 readonly property bool sideStageEnabled: root.shellOrientation == Qt.LandscapeOrientation ||

271 root.shellOrientation == Qt.InvertedLandscapeOrientation

274 root.shellOrientation == Qt.InvertedLandscapeOrientation

272− Component.onCompleted: updateStageApps();

273 }

275 }

274

276

275− Connections {

277+ Instantiator {

276− target: ApplicationManager

278+ model: root.applicationManager

277− onFocusRequested: {

279+ delegate: Binding {

278− if (spreadView.interactive) {

280+ readonly property bool isDash: model.application ? model.application.appId == "unity8-dash" : false

279− spreadView.snapTo(priv.indexOf(appId));

281+ target: model.application

280− } else {

282+ property: "requestedState"

281− ApplicationManager.focusApplication(appId);

283+

282− }

284+ // NB: the first application clause is just to ensure we never get warnings for trying to access

285+ // members of a null variable.

286+ value: model.application &&

287+ (

288+ (isDash && root.keepDashRunning)

289+ || (!root.suspended && (model.application.appId === priv.mainStageAppId

290+ || model.application.appId === priv.sideStageAppId))

291+ )

292+ ? ApplicationInfoInterface.RequestedRunning

293+ : ApplicationInfoInterface.RequestedSuspended

283 }

294 }

295+ }

284

296

285− onApplicationAdded: {

297+ Binding {

286− if (spreadView.phase == 2) {

298+ target: MirFocusController

287− spreadView.snapTo(ApplicationManager.count - 1);

299+ property: "focusedSurface"

288− } else {

300+ value: priv.focusedAppDelegate ? priv.focusedAppDelegate.surface : null

289− spreadView.phase = 0;

290− spreadView.contentX = -spreadView.shift;

291− ApplicationManager.focusApplication(appId);

292− }

293− }

294−

295− onApplicationRemoved: {

296− if (priv.mainStageAppId == appId) {

297− ApplicationManager.focusApplication("unity8-dash")

298− }

299− if (priv.sideStageAppId == appId) {

300− var app = priv.getTopApp(ApplicationInfoInterface.SideStage);

301− priv.sideStageAppId = app === null ? "" : app.appId;

302− }

303−

304− if (ApplicationManager.count == 0) {

305− spreadView.phase = 0;

306− spreadView.contentX = -spreadView.shift;

307− } else if (spreadView.closingIndex == -1) {

308− // Unless we're closing the app ourselves in the spread,

309− // lets make sure the spread doesn't mess up by the changing app list.

310− spreadView.phase = 0;

311− spreadView.contentX = -spreadView.shift;

312−

313− ApplicationManager.focusApplication(ApplicationManager.get(0).appId);

314− }

315− }

316 }

301 }

317

302

318 Flickable {

303 Flickable {

@@ -363,16 +348,45 @@ AbstractStage {

363 property int selectedIndex: -1

348 property int selectedIndex: -1

364 property int draggedDelegateCount: 0

349 property int draggedDelegateCount: 0

365 property int closingIndex: -1

350 property int closingIndex: -1

366− property var selectedApplication: selectedIndex !== -1 ? ApplicationManager.get(selectedIndex) : null

351+ property var selectedDelegate: selectedIndex !== -1 ? spreadRepeater.itemAt(selectedIndex) : null

367−

352+

368− // FIXME: Workaround Flickable's not keepping its contentX still when resized

353+ // <FIXME-contentX> Workaround Flickable's behavior of bringing contentX back between valid boundaries

354+ // when resized. The proper way to fix this is refactoring PhoneStage so that it doesn't

355+ // rely on having Flickable.contentX keeping an out-of-bounds value when it's set programatically

356+ // (as opposed to having contentX reaching an out-of-bounds value through dragging, which will trigger

357+ // the Flickable.boundsBehavior upon release).

358+ onContentXChanged: {

359+ if (!undoContentXReset()) {

369− onContentXChanged: { forceItToRemainStillIfBeingResized(); }

360+ forceItToRemainStillIfBeingResized();

361+ }

362+ }

370 onShiftChanged: { forceItToRemainStillIfBeingResized(); }

363 onShiftChanged: { forceItToRemainStillIfBeingResized(); }

371 function forceItToRemainStillIfBeingResized() {

364 function forceItToRemainStillIfBeingResized() {

372− if (root.beingResized && contentX != -shift) {

365+ if (root.beingResized && contentX != -spreadView.shift) {

366+ contentX = -spreadView.shift;

367+ }

368+ }

369+ function undoContentXReset() {

370+ if (contentWidth === -1) {

371+ contentWidthOnLastContentXChange = contentWidth;

372+ lastContentX = contentX;

373+ return false;

374+ }

375+

376+ if (contentWidth != contentWidthOnLastContentXChange

377+ && lastContentX == -shift && contentX == 0) {

378+ // Flickable is resetting contentX because contentWidth has changed. Undo it.

373 contentX = -shift;

379 contentX = -shift;

380+ return true;

374 }

381 }

382+

383+ contentWidthOnLastContentXChange = contentWidth;

384+ lastContentX = contentX;

385+ return false;

375 }

386 }

387+ property real contentWidthOnLastContentXChange: -1

388+ property real lastContentX: 0

389+ // </FIXME-contentX>

376

390

377 property bool animateX: true

391 property bool animateX: true

378 property bool beingResized: root.beingResized

392 property bool beingResized: root.beingResized

@@ -385,31 +399,33 @@ AbstractStage {

385 }

399 }

386 }

400 }

387

401

388− property real sideStageDragProgress: sideStage.progress

389− property bool sideStageVisible: priv.sideStageAppId

390 property real sideStageWidth: units.gu(40)

402 property real sideStageWidth: units.gu(40)

391

403

392 property bool surfaceDragging: triGestureArea.recognisedDrag

404 property bool surfaceDragging: triGestureArea.recognisedDrag

393

405

406+ readonly property bool sideStageVisible: priv.sideStageItemId != 0

407+

394− // In case the ApplicationManager already holds an app when starting up we're missing animations

408+ // In case applicationManager already holds an app when starting up we're missing animations

395 // Make sure we end up in the same state

409 // Make sure we end up in the same state

396 Component.onCompleted: {

410 Component.onCompleted: {

397 spreadView.contentX = -spreadView.shift

411 spreadView.contentX = -spreadView.shift

398 }

412 }

399

413

400 property int nextInStack: {

414 property int nextInStack: {

415+ var mainStageIndex = priv.mainStageDelegate ? priv.mainStageDelegate.index : -1;

416+ var sideStageIndex = priv.sideStageDelegate ? priv.sideStageDelegate.index : -1;

401 switch (state) {

417 switch (state) {

402 case "main":

418 case "main":

403− if (ApplicationManager.count > 1) {

419+ if (root.topLevelSurfaceList.count > 1) {

404 return 1;

420 return 1;

405 }

421 }

406 return -1;

422 return -1;

407 case "mainAndOverlay":

423 case "mainAndOverlay":

408− if (ApplicationManager.count <= 2) {

424+ if (root.topLevelSurfaceList.count <= 2) {

409 return -1;

425 return -1;

410 }

426 }

411− if (priv.appId0 == priv.mainStageAppId || priv.appId0 == priv.sideStageAppId) {

427+ if (mainStageIndex == 0 || sideStageIndex == 0) {

412− if (priv.appId1 == priv.mainStageAppId || priv.appId1 == priv.sideStageAppId) {

428+ if (mainStageIndex == 1 || sideStageIndex == 1) {

413 return 2;

429 return 2;

414 }

430 }

415 return 1;

431 return 1;

@@ -420,7 +436,7 @@ AbstractStage {

420 }

436 }

421 return -1;

437 return -1;

422 }

438 }

423− property int nextZInStack: indexToZIndex(nextInStack)

439+ property int nextZInStack

424

440

425 states: [

441 states: [

426 State {

442 State {

@@ -440,13 +456,13 @@ AbstractStage {

440 }

456 }

441 ]

457 ]

442 state: {

458 state: {

443− if ((priv.mainStageAppId && !priv.sideStageAppId) || !priv.sideStageEnabled) {

459+ if ((priv.mainStageItemId && !priv.sideStageItemId) || !priv.sideStageEnabled) {

444 return "main";

460 return "main";

445 }

461 }

446− if (!priv.mainStageAppId && priv.sideStageAppId) {

462+ if (!priv.mainStageItemId && priv.sideStageItemId) {

447 return "overlay";

463 return "overlay";

448 }

464 }

449− if (priv.mainStageAppId && priv.sideStageAppId) {

465+ if (priv.mainStageItemId && priv.sideStageItemId) {

450 return "mainAndOverlay";

466 return "mainAndOverlay";

451 }

467 }

452 return "empty";

468 return "empty";

@@ -511,7 +527,7 @@ AbstractStage {

511 // only shuffle when we've got a main and overlay

527 // only shuffle when we've got a main and overlay

512 if (state !== "mainAndOverlay") return index;

528 if (state !== "mainAndOverlay") return index;

513

529

514− var app = ApplicationManager.get(index);

530+ var app = root.topLevelSurfaceList.applicationAt(index);

515 if (!app) {

531 if (!app) {

516 return index;

532 return index;

517 }

533 }

@@ -519,20 +535,23 @@ AbstractStage {

519 // don't shuffle indexes greater than "actives or next"

535 // don't shuffle indexes greater than "actives or next"

520 if (index > 2) return index;

536 if (index > 2) return index;

521

537

522− if (app.appId === priv.mainStageAppId) {

538+ var mainStageIndex = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);

539+ var sideStageIndex = root.topLevelSurfaceList.indexForId(priv.sideStageItemId);

540+

541+ if (index == mainStageIndex) {

523 // Active main stage always at 0

542 // Active main stage always at 0

524 return 0;

543 return 0;

525 }

544 }

526

545

527 if (spreadView.nextInStack > 0) {

546 if (spreadView.nextInStack > 0) {

528− var nextAppInStack = ApplicationManager.get(spreadView.nextInStack);

547+ var nextAppInStack = root.topLevelSurfaceList.applicationAt(spreadView.nextInStack);

529

548

530 if (index === spreadView.nextInStack) {

549 if (index === spreadView.nextInStack) {

531 // this is the next app in stack.

550 // this is the next app in stack.

532

551

533 if (app.stage === ApplicationInfoInterface.SideStage) {

552 if (app.stage === ApplicationInfoInterface.SideStage) {

534 // if the next app in stack is a sidestage app, it must order on top of other side stage app

553 // if the next app in stack is a sidestage app, it must order on top of other side stage app

535− return Math.min(2, ApplicationManager.count-1);

554+ return Math.min(2, root.topLevelSurfaceList.count-1);

536 }

555 }

537 return 1;

556 return 1;

538 }

557 }

@@ -540,9 +559,9 @@ AbstractStage {

540 // if the next app in stack is a sidestage app, it must order on top of other side stage app

559 // if the next app in stack is a sidestage app, it must order on top of other side stage app

541 return 1;

560 return 1;

542 }

561 }

543− return Math.min(2, ApplicationManager.count-1);

562+ return Math.min(2, root.topLevelSurfaceList.count-1);

544 }

563 }

545− return Math.min(index+1, ApplicationManager.count-1);

564+ return Math.min(index+1, root.topLevelSurfaceList.count-1);

546 }

565 }

547

566

548 SequentialAnimation {

567 SequentialAnimation {

@@ -560,12 +579,13 @@ AbstractStage {

560 script: {

579 script: {

561 if (spreadView.selectedIndex >= 0) {

580 if (spreadView.selectedIndex >= 0) {

562 var newIndex = spreadView.selectedIndex;

581 var newIndex = spreadView.selectedIndex;

563− var application = ApplicationManager.get(newIndex);

582+ var application = root.topLevelSurfaceList.applicationAt(newIndex);

583+ var spreadDelegate = spreadRepeater.itemAt(newIndex);

564− if (application.stage === ApplicationInfoInterface.SideStage) {

584+ if (spreadDelegate.stage === ApplicationInfoInterface.SideStage) {

565 sideStage.showNow();

585 sideStage.showNow();

566 }

586 }

567 spreadView.selectedIndex = -1;

587 spreadView.selectedIndex = -1;

568− ApplicationManager.focusApplication(application.appId);

588+ spreadDelegate.focus = true;

569 spreadView.phase = 0;

589 spreadView.phase = 0;

570 spreadView.contentX = -spreadView.shift;

590 spreadView.contentX = -spreadView.shift;

571 }

591 }

@@ -581,7 +601,7 @@ AbstractStage {

581 MouseArea {

601 MouseArea {

582 id: spreadRow

602 id: spreadRow

583 x: spreadView.contentX

603 x: spreadView.contentX

584− width: spreadView.width + Math.max(spreadView.width, ApplicationManager.count * spreadView.tileDistance)

604+ width: spreadView.width + Math.max(spreadView.width, root.topLevelSurfaceList.count * spreadView.tileDistance)

585 height: root.height

605 height: root.height

586

606

587 onClicked: {

607 onClicked: {

@@ -599,8 +619,8 @@ AbstractStage {

599 enabled: priv.sideStageEnabled

619 enabled: priv.sideStageEnabled

600

620

601 onDropped: {

621 onDropped: {

602− priv.setAppStage(drag.source.appId, ApplicationInfoInterface.MainStage, true);

622+ drop.source.spreadDelegate.stage = ApplicationInfoInterface.MainStage;

603− ApplicationManager.focusApplication(drag.source.appId);

623+ drop.source.spreadDelegate.focus = true;

604 }

624 }

605 keys: "SideStage"

625 keys: "SideStage"

606 }

626 }

@@ -611,10 +631,10 @@ AbstractStage {

611 height: priv.landscapeHeight

631 height: priv.landscapeHeight

612 x: spreadView.width - width

632 x: spreadView.width - width

613 z: {

633 z: {

614− if (!priv.mainStageAppId) return 0;

634+ if (!priv.mainStageItemId) return 0;

615

635

616− if (priv.sideStageAppId && spreadView.nextInStack > 0) {

636+ if (priv.sideStageItemId && spreadView.nextInStack > 0) {

617− var nextAppInStack = ApplicationManager.get(spreadView.nextInStack);

637+ var nextAppInStack = root.topLevelSurfaceList.applicationAt(spreadView.nextInStack);

618

638

619 if (nextAppInStack.stage === ApplicationInfoInterface.MainStage) {

639 if (nextAppInStack.stage === ApplicationInfoInterface.MainStage) {

620 // if the next app in stack is a main stage app, put the sidestage on top of it.

640 // if the next app in stack is a main stage app, put the sidestage on top of it.

@@ -631,12 +651,11 @@ AbstractStage {

631 Behavior on opacity { UbuntuNumberAnimation {} }

651 Behavior on opacity { UbuntuNumberAnimation {} }

632

652

633 onShownChanged: {

653 onShownChanged: {

634− if (!shown && ApplicationManager.focusedApplicationId == priv.sideStageAppId) {

654+ if (!shown && priv.sideStageDelegate && priv.focusedAppDelegate === priv.sideStageDelegate

635− ApplicationManager.requestFocusApplication(priv.mainStageAppId);

655+ && priv.mainStageDelegate) {

636− }

656+ priv.mainStageDelegate.focus = true;

637− priv.updateStageApps();

657+ } else if (shown && priv.sideStageDelegate) {

638− if (shown && priv.sideStageAppId) {

658+ priv.sideStageDelegate.focus = true;

639− ApplicationManager.requestFocusApplication(priv.sideStageAppId);

640 }

659 }

641 }

660 }

642

661

@@ -655,8 +674,8 @@ AbstractStage {

655 }

674 }

656 onDropped: {

675 onDropped: {

657 if (drop.keys == "MainStage") {

676 if (drop.keys == "MainStage") {

658− priv.setAppStage(drop.source.appId, ApplicationInfoInterface.SideStage, true);

677+ drop.source.spreadDelegate.stage = ApplicationInfoInterface.SideStage;

659− ApplicationManager.requestFocusApplication(drop.source.appId);

678+ drop.source.spreadDelegate.focus = true;

660 }

679 }

661 }

680 }

662 drag {

681 drag {

@@ -672,38 +691,85 @@ AbstractStage {

672 Repeater {

691 Repeater {

673 id: spreadRepeater

692 id: spreadRepeater

674 objectName: "spreadRepeater"

693 objectName: "spreadRepeater"

675− model: ApplicationManager

694+ model: root.topLevelSurfaceList

695+

696+ onItemAdded: {

697+ if (spreadView.phase == 2) {

698+ spreadView.snapTo(index);

699+ }

700+ }

701+

702+ onItemRemoved: {

703+ // Unless we're closing the app ourselves in the spread,

704+ // lets make sure the spread doesn't mess up by the changing app list.

705+ if (spreadView.closingIndex == -1) {

706+ spreadView.phase = 0;

707+ spreadView.contentX = -spreadView.shift;

708+ focusTopMostApp();

709+ }

710+ }

711+ function focusTopMostApp() {

712+ if (spreadRepeater.count > 0) {

713+ var topmostDelegate = spreadRepeater.itemAt(0);

714+ topmostDelegate.focus = true;

715+ }

716+ }

676

717

677 delegate: TransformedTabletSpreadDelegate {

718 delegate: TransformedTabletSpreadDelegate {

678 id: spreadTile

719 id: spreadTile

679− objectName: model.appId ? "tabletSpreadDelegate_" + model.appId

720+ objectName: "spreadDelegate_" + model.id

680− : "tabletSpreadDelegate_null";

721+

722+ property int index: model.index

681 width: spreadView.width

723 width: spreadView.width

682 height: spreadView.height

724 height: spreadView.height

683− active: appId == priv.mainStageAppId || appId == priv.sideStageAppId

725+ active: model.id == priv.mainStageItemId || model.id == priv.sideStageItemId

684 zIndex: selected && stage == ApplicationInfoInterface.MainStage ? 0 : spreadView.indexToZIndex(index)

726 zIndex: selected && stage == ApplicationInfoInterface.MainStage ? 0 : spreadView.indexToZIndex(index)

727+ onZIndexChanged: {

728+ if (spreadView.nextInStack == model.index) {

729+ spreadView.nextZInStack = zIndex;

730+ }

731+ }

685 selected: spreadView.selectedIndex == index

732 selected: spreadView.selectedIndex == index

686 otherSelected: spreadView.selectedIndex >= 0 && !selected

733 otherSelected: spreadView.selectedIndex >= 0 && !selected

687− isInSideStage: priv.sideStageAppId === appId

734+ isInSideStage: priv.sideStageItemId == model.id

688 interactive: !spreadView.interactive && spreadView.phase === 0 && root.interactive

735 interactive: !spreadView.interactive && spreadView.phase === 0 && root.interactive

689 swipeToCloseEnabled: spreadView.interactive && !snapAnimation.running

736 swipeToCloseEnabled: spreadView.interactive && !snapAnimation.running

690 maximizedAppTopMargin: root.maximizedAppTopMargin

737 maximizedAppTopMargin: root.maximizedAppTopMargin

738+ dragOffset: !isDash && model.id == priv.mainStageItemId && root.inverseProgress > 0

691− dragOffset: !isDash && appId == priv.mainStageAppId && root.inverseProgress > 0 && spreadView.phase === 0 ? root.inverseProgress : 0

739+ && spreadView.phase === 0 ? root.inverseProgress : 0

692− application: ApplicationManager.get(index)

740+ application: model.application

741+ surface: model.surface

693 closeable: !isDash

742 closeable: !isDash

694 highlightShown: root.altTabPressed && priv.highlightIndex == zIndex

743 highlightShown: root.altTabPressed && priv.highlightIndex == zIndex

695

744

696− readonly property bool wantsMainStage: model.stage == ApplicationInfoInterface.MainStage

745+ readonly property bool wantsMainStage: stage == ApplicationInfoInterface.MainStage

697

746

698− readonly property string appId: model.appId

699− readonly property bool isDash: model.appId == "unity8-dash"

747+ readonly property bool isDash: model.application.appId == "unity8-dash"

748+

749+ onFocusChanged: {

750+ if (focus) {

751+ priv.focusedAppDelegate = spreadTile;

752+ root.topLevelSurfaceList.move(model.id, 0);

753+ }

754+ if (focus && priv.sideStageEnabled && stage === ApplicationInfoInterface.SideStage) {

755+ sideStage.show();

756+ }

757+ }

758+ Connections {

759+ target: model.surface

760+ onFocusRequested: spreadTile.focus = true;

761+ }

700

762

701− stage: model.stage

702 fullscreen: {

763 fullscreen: {

703− if (mainApp && stage === ApplicationInfoInterface.SideStage) {

764+ if (priv.mainStageDelegate && stage === ApplicationInfoInterface.SideStage) {

704− return mainApp.fullscreen;

765+ return priv.mainStageDelegate.fullscreen;

766+ } else if (surface) {

767+ return surface.state === Mir.FullscreenState;

768+ } else if (application) {

769+ return application.fullscreen;

770+ } else {

771+ return false;

705 }

772 }

706− return application ? application.fullscreen : false;

707 }

773 }

708

774

709 supportedOrientations: {

775 supportedOrientations: {

@@ -724,21 +790,10 @@ AbstractStage {

724 }

790 }

725 }

791 }

726

792

727−

728 Binding {

793 Binding {

729 target: spreadTile.application

794 target: spreadTile.application

730 property: "exemptFromLifecycle"

795 property: "exemptFromLifecycle"

731− value: !model.isTouchApp || isExemptFromLifecycle(model.appId)

796+ value: !model.application.isTouchApp || isExemptFromLifecycle(model.application.appId)

732− }

733−

734− Binding {

735− target: spreadTile.application

736− property: "requestedState"

737− value: (isDash && root.keepDashRunning)

738− || (!root.suspended && (model.appId == priv.mainStageAppId

739− || model.appId == priv.sideStageAppId))

740− ? ApplicationInfoInterface.RequestedRunning

741− : ApplicationInfoInterface.RequestedSuspended

742 }

797 }

743

798

744 // FIXME: A regular binding doesn't update any more after closing an app.

799 // FIXME: A regular binding doesn't update any more after closing an app.

@@ -760,34 +815,35 @@ AbstractStage {

760 onSideStageEnabledChanged: refreshStage()

815 onSideStageEnabledChanged: refreshStage()

761 }

816 }

762

817

818+ property bool _constructing: true;

819+ onStageChanged: {

820+ if (!_constructing) {

821+ priv.updateMainAndSideStageIndexes();

822+ }

823+ }

824+

763 Component.onCompleted: {

825 Component.onCompleted: {

826+ // a top level window is always the focused one when it first appears, unfocusing

827+ // any preexisting one

828+ if (model.index == 0) {

829+ focus = true;

830+ }

764− refreshStage()

831+ refreshStage();

765− stageChanged.connect(priv.updateStageApps);

832+ _constructing = false;

833+ }

834+ Component.onDestruction: {

835+ WindowStateStorage.saveStage(model.application.appId, stage);

766 }

836 }

767

837

768 function refreshStage() {

838 function refreshStage() {

769− var stage = ApplicationInfoInterface.MainStage;

839+ var newStage = ApplicationInfoInterface.MainStage;

770 if (priv.sideStageEnabled) {

840 if (priv.sideStageEnabled) {

771 if (application && application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {

841 if (application && application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {

772− stage = WindowStateStorage.getStage(appId);

842+ newStage = WindowStateStorage.getStage(application.appId);

773 }

843 }

774 }

844 }

775

845

776− if (model.stage !== stage) {

846+ stage = newStage;

777− priv.setAppStage(appId, stage, false);

778− }

779− }

780−

781− // This is required because none of the bindings are triggered in some cases:

782− // When an app is closed, it might happen that ApplicationManager.get(nextInStack)

783− // returns a different app even though the nextInStackIndex and all the related

784− // bindings (index, mainStageApp, sideStageApp, etc) don't change. Let's force a

785− // binding update in that case.

786− Connections {

787− target: ApplicationManager

788− onApplicationRemoved: spreadTile.z = Qt.binding(function() {

789− return spreadView.indexToZIndex(index);

790− })

791 }

847 }

792

848

793 progress: {

849 progress: {

@@ -873,12 +929,13 @@ AbstractStage {

873 script: {

929 script: {

874 // rotate immediately.

930 // rotate immediately.

875 spreadTile.matchShellOrientation();

931 spreadTile.matchShellOrientation();

876− if (ApplicationManager.focusedApplicationId === spreadTile.appId &&

932+ if (priv.focusedAppDelegate === spreadTile &&

877 priv.sideStageEnabled && !sideStage.shown) {

933 priv.sideStageEnabled && !sideStage.shown) {

878 // Sidestage was focused, so show the side stage.

934 // Sidestage was focused, so show the side stage.

879 sideStage.show();

935 sideStage.show();

880 // if we've switched to a main app which doesnt support portrait, hide the side stage.

936 // if we've switched to a main app which doesnt support portrait, hide the side stage.

937+ } else if (priv.sideStageDelegate === spreadTile &&

881− } else if (mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {

938+ mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {

882 sideStage.hideNow();

939 sideStage.hideNow();

883 }

940 }

884 }

941 }

@@ -890,10 +947,10 @@ AbstractStage {

890 SequentialAnimation {

947 SequentialAnimation {

891 ScriptAction {

948 ScriptAction {

892 script: {

949 script: {

893− if (priv.sideStageAppId === spreadTile.appId &&

950+ if (priv.sideStageDelegate === spreadTile &&

894 mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {

951 mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {

895 // The mainstage app did not natively support portrait orientation, so focus the sidestage.

952 // The mainstage app did not natively support portrait orientation, so focus the sidestage.

896− ApplicationManager.requestFocusApplication(spreadTile.appId);

953+ spreadTile.focus = true;

897 }

954 }

898 }

955 }

899 }

956 }

@@ -922,28 +979,26 @@ AbstractStage {

922

979

923 onClosed: {

980 onClosed: {

924 spreadView.closingIndex = index;

981 spreadView.closingIndex = index;

925− ApplicationManager.stopApplication(ApplicationManager.get(index).appId);

982+ if (spreadTile.surface) {

926− }

983+ spreadTile.surface.close();

927−

984+ } else if (spreadTile.application) {

928− onFocusChanged: {

985+ root.applicationManager.stopApplication(spreadTile.application.appId);

929− if (focus && ApplicationManager.focusedApplicationId !== appId) {

986+ } else {

930− ApplicationManager.focusApplication(appId);

987+ // should never happen

931− }

988+ console.warn("Can't close topLevelSurfaceList entry as it has neither"

932−

989+ + " a surface nor an application");

933− if (focus && priv.sideStageEnabled && stage === ApplicationInfoInterface.SideStage) {

934− sideStage.show();

935 }

990 }

936 }

991 }

937

992

938 Binding {

993 Binding {

939 target: root

994 target: root

940− when: model.appId == priv.mainStageAppId

995+ when: model.id == priv.mainStageItemId

941 property: "mainAppWindowOrientationAngle"

996 property: "mainAppWindowOrientationAngle"

942 value: appWindowOrientationAngle

997 value: appWindowOrientationAngle

943 }

998 }

944 Binding {

999 Binding {

945 target: priv

1000 target: priv

946− when: model.appId == priv.mainStageAppId

1001+ when: model.id == priv.mainStageItemId

947 property: "mainAppOrientationChangesEnabled"

1002 property: "mainAppOrientationChangesEnabled"

948 value: orientationChangesEnabled

1003 value: orientationChangesEnabled

949 }

1004 }

@@ -973,17 +1028,19 @@ AbstractStage {

973 anchors.fill: parent

1028 anchors.fill: parent

974 enabled: priv.sideStageEnabled && !spreadView.active

1029 enabled: priv.sideStageEnabled && !spreadView.active

975 property var dragObject: null

1030 property var dragObject: null

976− property string appId: ""

1031+

1032+ property Item spreadDelegate

1033+

977 dragComponent: dragComponent

1034 dragComponent: dragComponent

978− dragComponentProperties: { "appId": appId }

1035+ dragComponentProperties: { "spreadDelegate": spreadDelegate }

979

1036

980 onPressed: {

1037 onPressed: {

981− function matchDelegate(obj) { return String(obj.objectName).indexOf("tabletSpreadDelegate") >= 0; }

1038+ function matchDelegate(obj) { return String(obj.objectName).indexOf("spreadDelegate") >= 0; }

982

1039

983 var delegateAtCenter = Functions.itemAt(spreadRow, x, y, matchDelegate);

1040 var delegateAtCenter = Functions.itemAt(spreadRow, x, y, matchDelegate);

984 if (!delegateAtCenter) return;

1041 if (!delegateAtCenter) return;

985

1042

986− appId = delegateAtCenter.appId;

1043+ spreadDelegate = delegateAtCenter;

987 }

1044 }

988

1045

989 onClicked: {

1046 onClicked: {

@@ -1003,11 +1060,11 @@ AbstractStage {

1003

1060

1004 Component {

1061 Component {

1005 id: dragComponent

1062 id: dragComponent

1006− SessionContainer {

1063+ SurfaceContainer {

1007− property string appId: ""

1064+ property Item spreadDelegate

1008− property var application: ApplicationManager.findApplication(appId)

1065+

1066+ surface: spreadDelegate ? spreadDelegate.surface : null

1009

1067

1010− session: application ? application.session : null

1011 interactive: false

1068 interactive: false

1012 resizeSurface: false

1069 resizeSurface: false

1013 focus: false

1070 focus: false

@@ -1019,10 +1076,11 @@ AbstractStage {

1019 Drag.hotSpot.y: height/2

1076 Drag.hotSpot.y: height/2

1020 // only accept opposite stage.

1077 // only accept opposite stage.

1021 Drag.keys: {

1078 Drag.keys: {

1022− if (!application) return "Disabled";

1079+ if (!surface) return "Disabled";

1023

1080

1024− if (application.stage === ApplicationInfo.MainStage) {

1081+ if (spreadDelegate.stage === ApplicationInfo.MainStage) {

1082+ if (spreadDelegate.application.supportedOrientations

1025− if (application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {

1083+ & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {

1026 return "MainStage";

1084 return "MainStage";

1027 }

1085 }

1028 return "Disabled";

1086 return "Disabled";

qml/Stages/TransformedSpreadDelegate.qml+4−4

@@ -1,5 +1,5 @@

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

@@ -312,7 +312,7 @@ SpreadDelegate {

312 // non-fullscreen window when they're stacked on top of each other on the

313 // far left of the spread.

314 Translate {

315− y: !fullscreen && appWindowRotation === 180

315+ y: !root.fullscreen && appWindowRotation === 180

316 ? priv.topMarginProgress * maximizedAppTopMargin

317 : 0

318 },

@@ -326,7 +326,7 @@ SpreadDelegate {

326 switch (appWindowRotation) {

327 case 90:

328 case 270:

329− if (fullscreen) {

329+ if (root.fullscreen) {

330 return 1;

331 } else {

332 return 1 + priv.topMarginProgress * maximizedAppTopMargin / spreadView.width;

@@ -340,7 +340,7 @@ SpreadDelegate {

340 yScale: {

341 switch (appWindowRotation) {

342 case 0:

343− if (fullscreen) {

343+ if (root.fullscreen) {

344 return 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height;

345 } else {

346 return 1;

qml/Stages/TransformedTabletSpreadDelegate.qml+29−23

@@ -31,7 +31,6 @@ SpreadDelegate {

31 // Set this to true when this tile a currently active on either the MS or the SS.

32 property bool active: false

34− property int stage

35 property int zIndex

34 property int zIndex

36 property real progress: 0

35 property real progress: 0

37 property real animatedProgress: 0

36 property real animatedProgress: 0

@@ -48,13 +47,15 @@ SpreadDelegate {

49 property bool isInSideStage: false

48 property bool isInSideStage: false

50+ property int stage: ApplicationInfoInterface.MainStage

51+

51 property int dragOffset: 0

52 property int dragOffset: 0

52 readonly property alias xTranslateAnimating: xTranslateAnimation.running

53 readonly property alias xTranslateAnimating: xTranslateAnimation.running

53 readonly property bool offScreen: priv.xTranslate >= 0

54 readonly property bool offScreen: priv.xTranslate >= 0

55 dropShadow: spreadView.active ||

56 dropShadow: spreadView.active ||

56 (active

57 (active

57− && (stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)

58+ && (root.stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)

58 && priv.xTranslate != 0)

59 && priv.xTranslate != 0)

60 onSelectedChanged: {

61 onSelectedChanged: {

@@ -90,7 +91,7 @@ SpreadDelegate {

90 id: priv

91 id: priv

92 // true if this is the next tile on the stack that comes in when dragging from the right

93 // true if this is the next tile on the stack that comes in when dragging from the right

93− property bool nextInStack: spreadView.nextZInStack == zIndex

94+ property bool nextInStack: spreadView.nextInStack == model.index

94 // true if the next tile in the stack is the nextInStack one. This one will be moved a bit to the left

95 // true if the next tile in the stack is the nextInStack one. This one will be moved a bit to the left

95 property bool movedActive: spreadView.nextZInStack == zIndex + 1

96 property bool movedActive: spreadView.nextZInStack == zIndex + 1

96 property real animatedEndDistance: linearAnimation(0, 2, root.endDistance, 0, root.progress)

97 property real animatedEndDistance: linearAnimation(0, 2, root.endDistance, 0, root.progress)

@@ -142,7 +143,7 @@ SpreadDelegate {

142 Behavior on xTranslate {

143 Behavior on xTranslate {

143 enabled: !spreadView.active &&

144 enabled: !spreadView.active &&

144 !snapAnimation.running &&

145 !snapAnimation.running &&

145− model.appId !== "unity8-dash" &&

146+ root.application.appId !== "unity8-dash" &&

146 spreadView.animateX &&

147 spreadView.animateX &&

147 !spreadView.beingResized &&

148 !spreadView.beingResized &&

148 priv.state !== "sideStage"

149 priv.state !== "sideStage"

@@ -156,8 +157,9 @@ SpreadDelegate {

156 var newTranslate = 0;

157 var newTranslate = 0;

157

158

158 // selected app or opposite stage active app.

159 // selected app or opposite stage active app.

159− if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {

160+ if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate

161+ && spreadView.selectedDelegate.stage !== root.stage)) {

160− if (stage == ApplicationInfoInterface.MainStage) {

162+ if (root.stage == ApplicationInfoInterface.MainStage) {

161 return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.width, root.progress);

163 return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.width, root.progress);

162 } else {

164 } else {

163 return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.sideStageWidth, root.progress);

165 return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.sideStageWidth, root.progress);

@@ -168,8 +170,8 @@ SpreadDelegate {

168

170

169 // The tile should move a bit to the left if a new one comes on top of it, but not for the Side Stage and not

171 // The tile should move a bit to the left if a new one comes on top of it, but not for the Side Stage and not

170 // when we're only dragging the side stage in on top of a main stage app

172 // when we're only dragging the side stage in on top of a main stage app

171− var shouldMoveAway = spreadView.nextInStack >= 0 && priv.movedActive && stage === ApplicationInfoInterface.MainStage &&

173+ var shouldMoveAway = spreadView.nextInStack >= 0 && priv.movedActive && root.stage === ApplicationInfoInterface.MainStage &&

172− ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage;

174+ topLevelSurfaceList.applicationAt(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage;

173

175

174 if (active) {

176 if (active) {

175 newTranslate -= root.width

177 newTranslate -= root.width

@@ -178,7 +180,7 @@ SpreadDelegate {

178 newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -units.gu(4), root.animatedProgress);

180 newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -units.gu(4), root.animatedProgress);

179 }

181 }

180 newTranslate += root.dragOffset;

182 newTranslate += root.dragOffset;

181− } else if (!spreadView.active && model.appId == "unity8-dash") {

183+ } else if (!spreadView.active && root.application.appId == "unity8-dash") {

182 newTranslate -= root.width;

184 newTranslate -= root.width;

183 }

185 }

184

186

@@ -190,14 +192,14 @@ SpreadDelegate {

190

192

191 if (spreadView.phase == 0) {

193 if (spreadView.phase == 0) {

192 if (nextInStack) {

194 if (nextInStack) {

193− if (stage == ApplicationInfoInterface.MainStage) {

195+ if (root.stage == ApplicationInfoInterface.MainStage) {

194 if (spreadView.sideStageVisible && root.progress > 0) {

196 if (spreadView.sideStageVisible && root.progress > 0) {

195 // Move it so it appears from behind the side stage immediately

197 // Move it so it appears from behind the side stage immediately

196 newTranslate += -spreadView.sideStageWidth;

198 newTranslate += -spreadView.sideStageWidth;

197 }

199 }

198 }

200 }

199

201

200− if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

202+ if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

201 // This is when we only drag the side stage in, without rotation or snapping

203 // This is when we only drag the side stage in, without rotation or snapping

202 newTranslate = linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth, root.animatedProgress);

204 newTranslate = linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth, root.animatedProgress);

203 } else {

205 } else {

@@ -210,7 +212,7 @@ SpreadDelegate {

210

212

211 if (spreadView.phase == 1) {

213 if (spreadView.phase == 1) {

212 if (nextInStack) {

214 if (nextInStack) {

213− if (stage == ApplicationInfoInterface.MainStage) {

215+ if (root.stage == ApplicationInfoInterface.MainStage) {

214 var startValue = -spreadView.sideStageWidth * spreadView.snapPosition + (spreadView.sideStageVisible ? -spreadView.sideStageWidth : 0);

216 var startValue = -spreadView.sideStageWidth * spreadView.snapPosition + (spreadView.sideStageVisible ? -spreadView.sideStageWidth : 0);

215 newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startValue, priv.phase2StartTranslate, root.animatedProgress);

217 newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startValue, priv.phase2StartTranslate, root.animatedProgress);

216 } else {

218 } else {

@@ -250,7 +252,8 @@ SpreadDelegate {

250 }

252 }

251

253

252 // selected app or opposite stage active app.

254 // selected app or opposite stage active app.

253− if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {

255+ if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate

256+ && spreadView.selectedDelegate.stage !== root.stage)) {

254 return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);

257 return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);

255 } else if (otherSelected) {

258 } else if (otherSelected) {

256 return selectedScale;

259 return selectedScale;

@@ -258,7 +261,7 @@ SpreadDelegate {

258

261

259 if (spreadView.phase == 0) {

262 if (spreadView.phase == 0) {

260 if (nextInStack) {

263 if (nextInStack) {

261− if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

264+ if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

262 return 1;

265 return 1;

263 } else {

266 } else {

264 var targetScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);

267 var targetScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);

@@ -272,7 +275,7 @@ SpreadDelegate {

272 if (spreadView.phase == 1) {

275 if (spreadView.phase == 1) {

273 if (nextInStack) {

276 if (nextInStack) {

274 var startScale = 1;

277 var startScale = 1;

275− if (stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {

278+ if (root.stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {

276 startScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);

279 startScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);

277 }

280 }

278 return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startScale, priv.phase2StartScale, root.animatedProgress);

281 return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startScale, priv.phase2StartScale, root.animatedProgress);

@@ -295,7 +298,8 @@ SpreadDelegate {

295 }

298 }

296

299

297 // selected app or opposite stage active app.

300 // selected app or opposite stage active app.

298− if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {

301+ if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate

302+ && spreadView.selectedDelegate.stage !== root.stage)) {

299 return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);

303 return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);

300 } else if (otherSelected) {

304 } else if (otherSelected) {

301 return selectedAngle;

305 return selectedAngle;

@@ -304,12 +308,12 @@ SpreadDelegate {

304 // The tile should rotate a bit when another one comes on top, but not when only dragging the side stage in

308 // The tile should rotate a bit when another one comes on top, but not when only dragging the side stage in

305 var shouldMoveAway = spreadView.nextInStack == -1 ||

309 var shouldMoveAway = spreadView.nextInStack == -1 ||

306 spreadView.nextInStack >= 0 && priv.movedActive &&

310 spreadView.nextInStack >= 0 && priv.movedActive &&

307− (ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage ||

311+ (topLevelSurfaceList.applicationAt(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage ||

308− stage == ApplicationInfoInterface.SideStage);

312+ root.stage == ApplicationInfoInterface.SideStage);

309

313

310 if (spreadView.phase == 0) {

314 if (spreadView.phase == 0) {

311 if (nextInStack) {

315 if (nextInStack) {

312− if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

316+ if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

313 return 0;

317 return 0;

314 } else {

318 } else {

315 return linearAnimation(0, spreadView.positionMarker2, root.startAngle, root.startAngle * (1-spreadView.snapPosition), root.animatedProgress);

319 return linearAnimation(0, spreadView.positionMarker2, root.startAngle, root.startAngle * (1-spreadView.snapPosition), root.animatedProgress);

@@ -321,7 +325,7 @@ SpreadDelegate {

321 }

325 }

322 if (spreadView.phase == 1) {

326 if (spreadView.phase == 1) {

323 if (nextInStack) {

327 if (nextInStack) {

324− if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

328+ if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {

325 return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, 0, priv.phase2StartAngle, root.animatedProgress);

329 return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, 0, priv.phase2StartAngle, root.animatedProgress);

326 } else {

330 } else {

327 return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, root.startAngle * (1-spreadView.snapPosition), priv.phase2StartAngle, root.animatedProgress);

331 return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, root.startAngle * (1-spreadView.snapPosition), priv.phase2StartAngle, root.animatedProgress);

@@ -345,7 +349,8 @@ SpreadDelegate {

345 if (root.isSelected) return 1;

349 if (root.isSelected) return 1;

346

350

347 if (otherSelected) {

351 if (otherSelected) {

348− if (root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage) {

352+ if (root.active && spreadView.selectedDelegate

353+ && spreadView.selectedDelegate.stage !== root.stage) {

349 return 1;

354 return 1;

350 }

355 }

351 return linearAnimation(selectedProgress, negativeProgress, selectedOpacity, 0, root.progress);

356 return linearAnimation(selectedProgress, negativeProgress, selectedOpacity, 0, root.progress);

@@ -355,7 +360,8 @@ SpreadDelegate {

355

360

356 property real topMarginProgress: {

361 property real topMarginProgress: {

357 // selected app or opposite stage active app.

362 // selected app or opposite stage active app.

358− if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {

363+ if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate

364+ && spreadView.selectedDelegate.stage !== root.stage)) {

359 return linearAnimation(selectedProgress, negativeProgress, selectedTopMarginProgress, 0, root.progress);

365 return linearAnimation(selectedProgress, negativeProgress, selectedTopMarginProgress, 0, root.progress);

360 }

366 }

361

367

@@ -379,7 +385,7 @@ SpreadDelegate {

379 when: root.isInSideStage && spreadView.shiftedContentX == 0 && spreadView.phase == 0

385 when: root.isInSideStage && spreadView.shiftedContentX == 0 && spreadView.phase == 0

380 PropertyChanges {

386 PropertyChanges {

381 target: priv;

387 target: priv;

382− xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * (1-spreadView.sideStageDragProgress)

388+ xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * (1-sideStage.progress)

383 }

389 }

384 }

390 }

385 ]

391 ]

qml/Stages/WindowedFullscreenPolicy.qml+5−7

@@ -23,19 +23,17 @@ import Unity.Application 0.1

23// state of the window is returned to restored.

24QtObject {

25 property bool active: true

26− property QtObject application: null

26+ property QtObject surface: null

28− readonly property var lastSurface: application && application.session ?

29− application.session.lastSurface : null

30 property bool _firstTimeSurface: true

28 property bool _firstTimeSurface: true

32− onLastSurfaceChanged: {

30+ onSurfaceChanged: {

33− if (!active || !lastSurface) return;

31+ if (!active || !surface) return;

34 if (!_firstTimeSurface) return;

32 if (!_firstTimeSurface) return;

35 _firstTimeSurface = false;

33 _firstTimeSurface = false;

37− if (lastSurface.state === Mir.FullscreenState && lastSurface.shellChrome === Mir.LowChrome) {

35+ if (surface.state === Mir.FullscreenState && surface.shellChrome === Mir.LowChrome) {

38− lastSurface.state = Mir.RestoredState;

36+ surface.state = Mir.RestoredState;

39 }

37 }

40 }

38 }

41}

39}

tests/mocks/Unity/Application/ApplicationInfo.cpp+168−110

@@ -16,8 +16,7 @@

17#include "ApplicationInfo.h"

18#include "MirSurface.h"

19−#include "Session.h"

19+#include "SurfaceManager.h"

20−#include "SessionManager.h"

22#include <paths.h>

21#include <paths.h>

@@ -25,97 +24,108 @@

25#include <QQuickItem>

24#include <QQuickItem>

26#include <QQuickView>

25#include <QQuickView>

27#include <QQmlComponent>

26#include <QQmlComponent>

28−#include <QTimer>

27+

28+#define APPLICATION_DEBUG 0

29+

30+#if APPLICATION_DEBUG

31+#define DEBUG_MSG(params) qDebug().nospace() << "Application["<<appId()<<"]::" << __func__ << " " << params

32+

33+QString stateToStr(ApplicationInfo::State state)

34+{

35+ switch (state) {

36+ case ApplicationInfo::Starting:

37+ return "starting";

38+ case ApplicationInfo::Running:

39+ return "running";

40+ case ApplicationInfo::Suspended:

41+ return "suspended";

42+ case ApplicationInfo::Stopped:

43+ return "stopped";

44+ default:

45+ return "???";

46+ };

47+}

48+

49+#else

50+#define DEBUG_MSG(params) ((void)0)

51+#endif

30ApplicationInfo::ApplicationInfo(const QString &appId, QObject *parent)

53ApplicationInfo::ApplicationInfo(const QString &appId, QObject *parent)

31 : ApplicationInfoInterface(appId, parent)

54 : ApplicationInfoInterface(appId, parent)

32 , m_appId(appId)

55 , m_appId(appId)

33− , m_stage(MainStage)

34− , m_state(Stopped)

35− , m_focused(false)

36− , m_fullscreen(false)

37− , m_session(0)

38− , m_supportedOrientations(Qt::PortraitOrientation |

39− Qt::LandscapeOrientation |

40− Qt::InvertedPortraitOrientation |

41− Qt::InvertedLandscapeOrientation)

42− , m_rotatesWindowContents(false)

43− , m_requestedState(RequestedRunning)

44− , m_isTouchApp(true)

45− , m_exemptFromLifecycle(false)

46− , m_manualSurfaceCreation(false)

47− , m_shellChrome(Mir::NormalChrome)

48{

56{

57+ connect(&m_surfaceList, &MirSurfaceListModel::countChanged,

58+ this, &ApplicationInfo::onSurfaceCountChanged, Qt::QueuedConnection);

59+

60+ m_surfaceCreationTimer.setSingleShot(true);

61+ m_surfaceCreationTimer.setInterval(500);

62+ connect(&m_surfaceCreationTimer, &QTimer::timeout, this, &ApplicationInfo::createSurface);

49}

63}

51ApplicationInfo::ApplicationInfo(QObject *parent)

65ApplicationInfo::ApplicationInfo(QObject *parent)

52− : ApplicationInfoInterface(QString(), parent)

66+ : ApplicationInfo(QString(), parent)

53− , m_stage(MainStage)

54− , m_state(Stopped)

55− , m_focused(false)

56− , m_fullscreen(false)

57− , m_session(0)

58− , m_supportedOrientations(Qt::PortraitOrientation |

59− Qt::LandscapeOrientation |

60− Qt::InvertedPortraitOrientation |

61− Qt::InvertedLandscapeOrientation)

62− , m_rotatesWindowContents(false)

63− , m_requestedState(RequestedRunning)

64− , m_isTouchApp(true)

65− , m_exemptFromLifecycle(false)

66− , m_manualSurfaceCreation(false)

67− , m_shellChrome(Mir::NormalChrome)

68{

67{

69}

68}

71ApplicationInfo::~ApplicationInfo()

70ApplicationInfo::~ApplicationInfo()

72{

71{

73− delete m_session;

74−}

75−

76−void ApplicationInfo::createSession()

77−{

78− if (m_session || state() == ApplicationInfo::Stopped) { return; }

79−

80− setSession(SessionManager::singleton()->createSession(appId(), m_screenshotFileName));

81}

72}

83−void ApplicationInfo::destroySession()

74+void ApplicationInfo::createSurface()

84{

75{

85− Session *session = this->session();

76+ if (state() == ApplicationInfo::Stopped) { return; }

86− setSession(nullptr);

87− delete session;

88−}

90−void ApplicationInfo::setSession(Session* session)

78+ QString surfaceName = name();

91−{

79+ if (m_surfaceList.count() > 0) {

92− if (m_session == session)

80+ surfaceName.append(QString(" %1").arg(m_surfaceList.count()+1));

93− return;

94−

95− if (m_session) {

96− disconnect(this, 0, m_session, 0);

97− m_session->setApplication(nullptr);

98− m_session->setParent(nullptr);

99− Q_EMIT m_session->deregister();

100 }

81 }

101

102− m_session = session;

83+ auto surface = SurfaceManager::singleton()->createSurface(surfaceName,

103−

84+ Mir::NormalType,

104− if (m_session) {

85+ fullscreen() ? Mir::FullscreenState : Mir::MaximizedState,

105− m_session->setApplication(this);

86+ m_screenshotFileName);

106− m_session->setParent(this);

87+

107− m_session->setFullscreen(m_fullscreen);

88+ surface->setShellChrome(m_shellChrome);

108− SessionManager::singleton()->registerSession(m_session);

89+

109− connect(m_session, &Session::surfaceAdded,

90+ m_surfaceList.appendSurface(surface);

110− this, &ApplicationInfo::onSessionSurfaceAdded);

91+

111− connect(m_session, &Session::fullscreenChanged, this, &ApplicationInfo::fullscreenChanged);

92+ ++m_liveSurfaceCount;

93+ connect(surface, &MirSurface::liveChanged, this, [this, surface](){

94+ if (!surface->live()) {

95+ --m_liveSurfaceCount;

96+ if (m_liveSurfaceCount == 0) {

97+ if (m_closingSurfaces.contains(surface)

98+ || (m_state == Running && m_requestedState == RequestedRunning)) {

99+ Q_EMIT closed();

100+ }

101+ setState(Stopped);

102+ } else {

103+ if (m_closingSurfaces.contains(surface) && m_requestedState == RequestedSuspended

104+ && m_closingSurfaces.count() == 1) {

105+ setState(Suspended);

106+ }

107+ }

108+ m_closingSurfaces.removeAll(surface);

109+ }

110+ });

111+ connect(surface, &MirSurface::focusRequested, this, [this](){

112+ Q_EMIT this->focusRequested();

113+ });

114+ connect(surface, &MirSurface::closeRequested, this, [this, surface](){

115+ m_closingSurfaces.append(surface);

116+ if (m_state == Suspended) {

117+ // resume to allow application to close its surface

118+ setState(Running);

119+ }

120+ });

112

121

113− if (!m_manualSurfaceCreation) {

122+ if (m_state == Starting) {

114− QTimer::singleShot(500, m_session, &Session::createSurface);

123+ if (m_requestedState == RequestedRunning) {

124+ setState(Running);

125+ } else {

126+ setState(Suspended);

115 }

127 }

116 }

128 }

117−

118− Q_EMIT sessionChanged(m_session);

119}

129}

120

130

121void ApplicationInfo::setIconId(const QString &iconId)

131void ApplicationInfo::setIconId(const QString &iconId)

@@ -138,10 +148,6 @@ void ApplicationInfo::setScreenshotId(const QString &screenshotId)

138

148

139 if (screenshotFileName != m_screenshotFileName) {

149 if (screenshotFileName != m_screenshotFileName) {

140 m_screenshotFileName = screenshotFileName;

150 m_screenshotFileName = screenshotFileName;

141−

142− if (m_session) {

143− m_session->setScreenshot(screenshotFileName);

144− }

145 }

151 }

146}

152}

147

153

@@ -172,38 +178,53 @@ void ApplicationInfo::setStage(Stage value)

172void ApplicationInfo::setState(State value)

178void ApplicationInfo::setState(State value)

173{

179{

174 if (value != m_state) {

180 if (value != m_state) {

181+ DEBUG_MSG(qPrintable(stateToStr(value)));

182+ if (!m_manualSurfaceCreation && value == ApplicationInfo::Starting) {

183+ Q_ASSERT(m_surfaceList.count() == 0);

184+ m_surfaceCreationTimer.start();

185+ } else if (value == ApplicationInfo::Stopped) {

186+ m_surfaceCreationTimer.stop();

187+ for (int i = 0; i < m_surfaceList.count(); ++i) {

188+ MirSurface *surface = static_cast<MirSurface*>(m_surfaceList.get(i));

189+ surface->setLive(false);

190+ }

191+ }

192+

175 m_state = value;

193 m_state = value;

176 Q_EMIT stateChanged(value);

194 Q_EMIT stateChanged(value);

177−

178− if (!m_manualSurfaceCreation && !m_session && m_state == ApplicationInfo::Starting) {

179− QTimer::singleShot(500, this, &ApplicationInfo::createSession);

180− } else if (m_state == ApplicationInfo::Stopped) {

181− Session *session = m_session;

182− setSession(nullptr);

183− delete session;

184− }

185 }

195 }

186}

196}

187

197

188−void ApplicationInfo::setFocused(bool value)

198+void ApplicationInfo::close()

189{

199{

190− if (value != m_focused) {

200+ DEBUG_MSG("");

191− m_focused = value;

201+

192− Q_EMIT focusedChanged(value);

202+ if (m_surfaceList.count() > 0) {

203+ for (int i = 0; i < m_surfaceList.count(); ++i) {

204+ MirSurface *surface = static_cast<MirSurface*>(m_surfaceList.get(i));

205+ surface->close();

206+ }

207+ } else {

208+ setState(Stopped);

209+ Q_EMIT closed();

193 }

210 }

194}

211}

195

212

196void ApplicationInfo::setFullscreen(bool value)

213void ApplicationInfo::setFullscreen(bool value)

197{

214{

198 m_fullscreen = value;

215 m_fullscreen = value;

199− if (m_session) {

216+ if (m_surfaceList.rowCount() > 0) {

200− m_session->setFullscreen(value);

217+ m_surfaceList.get(0)->setState(Mir::FullscreenState);

201 }

218 }

202}

219}

203

220

204bool ApplicationInfo::fullscreen() const

221bool ApplicationInfo::fullscreen() const

205{

222{

206− return m_session ? m_session->fullscreen() : m_fullscreen;

223+ if (m_surfaceList.rowCount() > 0) {

224+ return m_surfaceList.get(0)->state() == Mir::FullscreenState;

225+ } else {

226+ return m_fullscreen;

227+ }

207}

228}

208

229

209void ApplicationInfo::setManualSurfaceCreation(bool value)

230void ApplicationInfo::setManualSurfaceCreation(bool value)

@@ -241,15 +262,28 @@ ApplicationInfo::RequestedState ApplicationInfo::requestedState() const

241

262

242void ApplicationInfo::setRequestedState(RequestedState value)

263void ApplicationInfo::setRequestedState(RequestedState value)

243{

264{

244− if (m_requestedState != value) {

265+ if (m_requestedState == value) {

266+ return;

267+ }

268+ DEBUG_MSG((value == RequestedRunning ? "RequestedRunning" : "RequestedSuspended") );

269+

245− m_requestedState = value;

270+ m_requestedState = value;

246− Q_EMIT requestedStateChanged(m_requestedState);

271+ Q_EMIT requestedStateChanged(m_requestedState);

272+

273+ if (m_requestedState == RequestedRunning) {

247

274

248− if (m_requestedState == RequestedRunning && m_state == Suspended) {

275+ if (m_state == Suspended) {

276+ Q_ASSERT(m_liveSurfaceCount > 0);

249 setState(Running);

277 setState(Running);

250− } else if (m_requestedState == RequestedSuspended && m_state == Running) {

278+ } else if (m_state == Stopped) {

279+ Q_ASSERT(m_liveSurfaceCount == 0);

280+ // it's restarting

251− setState(Suspended);

281+ setState(Starting);

252 }

282 }

283+

284+ } else if (m_requestedState == RequestedSuspended && m_state == Running

285+ && m_closingSurfaces.isEmpty()) {

286+ setState(Suspended);

253 }

287 }

254}

288}

255

289

@@ -263,18 +297,6 @@ void ApplicationInfo::setIsTouchApp(bool isTouchApp)

263 m_isTouchApp = isTouchApp;

297 m_isTouchApp = isTouchApp;

264}

298}

265

299

266−void ApplicationInfo::onSessionSurfaceAdded(MirSurface* surface)

267−{

268− if (surface != nullptr && m_state == Starting) {

269− if (m_requestedState == RequestedRunning) {

270− setState(Running);

271− } else {

272− setState(Suspended);

273− }

274− surface->setShellChrome(m_shellChrome);

275− }

276−}

277−

278bool ApplicationInfo::exemptFromLifecycle() const

300bool ApplicationInfo::exemptFromLifecycle() const

279{

301{

280 return m_exemptFromLifecycle;

302 return m_exemptFromLifecycle;

@@ -305,7 +327,43 @@ void ApplicationInfo::setInitialSurfaceSize(const QSize &size)

305void ApplicationInfo::setShellChrome(Mir::ShellChrome shellChrome)

327void ApplicationInfo::setShellChrome(Mir::ShellChrome shellChrome)

306{

328{

307 m_shellChrome = shellChrome;

329 m_shellChrome = shellChrome;

308− if (m_session && m_session->lastSurface()) {

330+ if (m_surfaceList.rowCount() > 0) {

309− m_session->lastSurface()->setShellChrome(shellChrome);

331+ static_cast<MirSurface*>(m_surfaceList.get(0))->setShellChrome(shellChrome);

332+ }

333+}

334+

335+bool ApplicationInfo::focused() const

336+{

337+ bool someSurfaceHasFocus = false; // to be proven wrong

338+ for (int i = 0; i < m_surfaceList.count() && !someSurfaceHasFocus; ++i) {

339+ someSurfaceHasFocus = m_surfaceList.get(i)->focused();

340+ }

341+ return someSurfaceHasFocus;

342+}

343+

344+void ApplicationInfo::setFocused(bool value)

345+{

346+ if (focused() == value) {

347+ return;

348+ }

349+

350+ if (value) {

351+ if (m_surfaceList.count() > 0) {

352+ m_surfaceList.get(0)->requestFocus();

353+ }

354+ } else {

355+ for (int i = 0; i < m_surfaceList.count(); ++i) {

356+ MirSurface *surface = static_cast<MirSurface*>(m_surfaceList.get(i));

357+ if (surface->focused()) {

358+ surface->setFocused(false);

359+ }

360+ }

361+ }

362+}

363+

364+void ApplicationInfo::onSurfaceCountChanged()

365+{

366+ if (m_surfaceList.count() == 0 && m_state == Running) {

367+ setState(Stopped);

310 }

368 }

311}

369}

tests/mocks/Unity/Application/ApplicationInfo.h+40−24

@@ -20,19 +20,24 @@

20#include <QObject>

22class MirSurface;

23−class Session;

25// unity-api

24// unity-api

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

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

27#include <unity/shell/application/Mir.h>

26#include <unity/shell/application/Mir.h>

28+#include "MirSurfaceListModel.h"

29+

30+#include <QList>

31+#include <QTimer>

32+

29using namespace unity::shell::application;

33using namespace unity::shell::application;

31class ApplicationInfo : public ApplicationInfoInterface {

35class ApplicationInfo : public ApplicationInfoInterface {

32 Q_OBJECT

36 Q_OBJECT

38+ ////

39+ // FIXME: Remove those

34 Q_PROPERTY(bool fullscreen READ fullscreen WRITE setFullscreen NOTIFY fullscreenChanged)

40 Q_PROPERTY(bool fullscreen READ fullscreen WRITE setFullscreen NOTIFY fullscreenChanged)

35− Q_PROPERTY(Session* session READ session NOTIFY sessionChanged)

37 // Only exists in this fake implementation

42 // Only exists in this fake implementation

@@ -66,8 +71,7 @@ public:

66 Q_INVOKABLE void setState(State value);

71 Q_INVOKABLE void setState(State value);

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

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

69− void setFocused(bool value);

70− bool focused() const override { return m_focused; }

74+ bool focused() const override;

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

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

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

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

@@ -100,21 +104,29 @@ public:

100 void setInitialSurfaceSize(const QSize &size) override;

104 void setInitialSurfaceSize(const QSize &size) override;

101

105

102 Q_INVOKABLE void setShellChrome(Mir::ShellChrome shellChrome);

106 Q_INVOKABLE void setShellChrome(Mir::ShellChrome shellChrome);

103−public:

107+

104− void setSession(Session* session);

108+ MirSurfaceListInterface* surfaceList() override { return &m_surfaceList; }

105− Session* session() const { return m_session; }

109+

110+ void setFocused(bool value);

111+

112+ //////

113+ // internal mock stuff

114+ void close();

106

115

107Q_SIGNALS:

116Q_SIGNALS:

108− void sessionChanged(Session*);

109 void fullscreenChanged(bool value);

117 void fullscreenChanged(bool value);

110 void manualSurfaceCreationChanged(bool value);

118 void manualSurfaceCreationChanged(bool value);

119+ void closed();

120+

121+ ////

122+ // FIXME: Move to unity::shell::application::ApplicationInfoInterface

123+ void focusRequested();

111

124

112public Q_SLOTS:

125public Q_SLOTS:

113− Q_INVOKABLE void createSession();

126+ Q_INVOKABLE void createSurface();

114− Q_INVOKABLE void destroySession();

115

127

116private Q_SLOTS:

128private Q_SLOTS:

117− void onSessionSurfaceAdded(MirSurface*);

129+ void onSurfaceCountChanged();

118

130

119private:

131private:

120 void setIcon(const QUrl &value);

132 void setIcon(const QUrl &value);

@@ -124,20 +136,24 @@ private:

124 QString m_appId;

136 QString m_appId;

125 QString m_name;

137 QString m_name;

126 QUrl m_icon;

138 QUrl m_icon;

127− Stage m_stage;

139+ Stage m_stage{MainStage};

128− State m_state;

140+ State m_state{Stopped};

129− bool m_focused;

130− bool m_fullscreen;

141+ bool m_fullscreen{false};

131− Session* m_session;

132− Qt::ScreenOrientations m_supportedOrientations;

142+ Qt::ScreenOrientations m_supportedOrientations{Qt::PortraitOrientation |

143+ Qt::LandscapeOrientation |

144+ Qt::InvertedPortraitOrientation |

145+ Qt::InvertedLandscapeOrientation};

133− bool m_rotatesWindowContents;

146+ bool m_rotatesWindowContents{false};

134− RequestedState m_requestedState;

147+ RequestedState m_requestedState{RequestedRunning};

135− bool m_isTouchApp;

148+ bool m_isTouchApp{true};

136− bool m_exemptFromLifecycle;

149+ bool m_exemptFromLifecycle{false};

137 QSize m_initialSurfaceSize;

150 QSize m_initialSurfaceSize;

138−

151+ MirSurfaceListModel m_surfaceList;

152+ int m_liveSurfaceCount{0};

153+ QTimer m_surfaceCreationTimer;

154+ QList<MirSurface*> m_closingSurfaces;

139− bool m_manualSurfaceCreation;

155+ bool m_manualSurfaceCreation{false};

140− Mir::ShellChrome m_shellChrome;

156+ Mir::ShellChrome m_shellChrome{Mir::NormalChrome};

141};

157};

142

158

143Q_DECLARE_METATYPE(ApplicationInfo*)

159Q_DECLARE_METATYPE(ApplicationInfo*)

tests/mocks/Unity/Application/ApplicationManager.cpp+104−40

@@ -1,5 +1,5 @@

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

@@ -16,8 +16,7 @@

17#include "ApplicationManager.h"

18#include "ApplicationInfo.h"

19−#include "Session.h"

19+#include "MirSurface.h"

20−#include "ApplicationTestInterface.h"

22#include <paths.h>

21#include <paths.h>

23#include <csignal>

22#include <csignal>

@@ -31,6 +30,16 @@

31#include <QDateTime>

30#include <QDateTime>

32#include <QtDBus/QtDBus>

31#include <QtDBus/QtDBus>

33+#define APPLICATIONMANAGER_DEBUG 0

34+

35+#if APPLICATIONMANAGER_DEBUG

36+#define DEBUG_MSG(params) qDebug().nospace() << "ApplicationManager::" << __func__ << " " << params

37+#else

38+#define DEBUG_MSG(params) ((void)0)

39+#endif

40+

41+namespace unityapi = unity::shell::application;

42+

34ApplicationManager *ApplicationManager::the_application_manager = nullptr;

43ApplicationManager *ApplicationManager::the_application_manager = nullptr;

36ApplicationManager *ApplicationManager::singleton()

45ApplicationManager *ApplicationManager::singleton()

@@ -50,9 +59,6 @@ ApplicationManager *ApplicationManager::singleton()

50ApplicationManager::ApplicationManager(QObject *parent)

59ApplicationManager::ApplicationManager(QObject *parent)

51 : ApplicationManagerInterface(parent)

60 : ApplicationManagerInterface(parent)

52{

61{

53− m_roleNames.insert(RoleSession, "session");

54− m_roleNames.insert(RoleFullscreen, "fullscreen");

55−

56 buildListOfAvailableApplications();

62 buildListOfAvailableApplications();

58 // polling to find out when the toplevel window has been created as there's

64 // polling to find out when the toplevel window has been created as there's

@@ -61,6 +67,9 @@ ApplicationManager::ApplicationManager(QObject *parent)

61 this, &ApplicationManager::onWindowCreatedTimerTimeout);

67 this, &ApplicationManager::onWindowCreatedTimerTimeout);

62 m_windowCreatedTimer.setSingleShot(false);

68 m_windowCreatedTimer.setSingleShot(false);

63 m_windowCreatedTimer.start(200);

69 m_windowCreatedTimer.start(200);

70+

71+ connect(MirFocusController::instance(), &MirFocusController::focusedSurfaceChanged,

72+ this, &ApplicationManager::updateFocusedApplication, Qt::QueuedConnection);

64}

73}

66ApplicationManager::~ApplicationManager()

75ApplicationManager::~ApplicationManager()

@@ -109,10 +118,8 @@ QVariant ApplicationManager::data(const QModelIndex& index, int role) const {

109 return app->isTouchApp();

118 return app->isTouchApp();

110 case RoleExemptFromLifecycle:

119 case RoleExemptFromLifecycle:

111 return app->exemptFromLifecycle();

120 return app->exemptFromLifecycle();

112− case RoleSession:

121+ case RoleApplication:

113− return QVariant::fromValue(app->session());

122+ return QVariant::fromValue(static_cast<unityapi::ApplicationInfoInterface*>(app));

114− case RoleFullscreen:

115− return app->fullscreen();

116 default:

123 default:

117 return QVariant();

124 return QVariant();

118 }

125 }

@@ -144,19 +151,17 @@ QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

144 return QModelIndex();

151 return QModelIndex();

145}

152}

146

153

147−void ApplicationManager::add(ApplicationInfo *application) {

154+bool ApplicationManager::add(ApplicationInfo *application) {

148 if (!application || m_runningApplications.contains(application)) {

155 if (!application || m_runningApplications.contains(application)) {

149− return;

156+ return false;

150 }

157 }

158+ DEBUG_MSG(application->appId());

159+

160+ application->setState(ApplicationInfo::Starting);

151

161

152 beginInsertRows(QModelIndex(), m_runningApplications.size(), m_runningApplications.size());

162 beginInsertRows(QModelIndex(), m_runningApplications.size(), m_runningApplications.size());

153 m_runningApplications.append(application);

163 m_runningApplications.append(application);

154

164

155− connect(application, &ApplicationInfo::sessionChanged, this, [application, this]() {

156− QModelIndex appIndex = findIndex(application);

157− if (!appIndex.isValid()) return;

158− Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleSession);

159− });

160 connect(application, &ApplicationInfo::focusedChanged, this, [application, this]() {

165 connect(application, &ApplicationInfo::focusedChanged, this, [application, this]() {

161 QModelIndex appIndex = findIndex(application);

166 QModelIndex appIndex = findIndex(application);

162 if (!appIndex.isValid()) return;

167 if (!appIndex.isValid()) return;

@@ -173,19 +178,27 @@ void ApplicationManager::add(ApplicationInfo *application) {

173 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleStage);

178 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleStage);

174 });

179 });

175

180

181+ connect(application, &ApplicationInfo::closed, this, [application, this]() {

182+ this->remove(application);

183+ });

184+ connect(application, &ApplicationInfo::focusRequested, this, [application, this]() {

185+ Q_EMIT this->focusRequested(application->appId());

186+ });

187+

176 endInsertRows();

188 endInsertRows();

177− Q_EMIT applicationAdded(application->appId());

178 Q_EMIT countChanged();

189 Q_EMIT countChanged();

179 if (count() == 1) Q_EMIT emptyChanged(isEmpty()); // was empty but not anymore

190 if (count() == 1) Q_EMIT emptyChanged(isEmpty()); // was empty but not anymore

191+

192+ return true;

180}

193}

181

194

182void ApplicationManager::remove(ApplicationInfo *application) {

195void ApplicationManager::remove(ApplicationInfo *application) {

183 int i = m_runningApplications.indexOf(application);

196 int i = m_runningApplications.indexOf(application);

184 if (i != -1) {

197 if (i != -1) {

198+ DEBUG_MSG(application->appId());

185 beginRemoveRows(QModelIndex(), i, i);

199 beginRemoveRows(QModelIndex(), i, i);

186 m_runningApplications.removeAt(i);

200 m_runningApplications.removeAt(i);

187 endRemoveRows();

201 endRemoveRows();

188− Q_EMIT applicationRemoved(application->appId());

189 Q_EMIT countChanged();

202 Q_EMIT countChanged();

190 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

203 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

191 }

204 }

@@ -209,18 +222,29 @@ void ApplicationManager::move(int from, int to) {

209ApplicationInfo* ApplicationManager::startApplication(const QString &appId,

222ApplicationInfo* ApplicationManager::startApplication(const QString &appId,

210 const QStringList &arguments)

223 const QStringList &arguments)

211{

224{

225+ DEBUG_MSG(appId);

212 Q_UNUSED(arguments)

226 Q_UNUSED(arguments)

227+

213− ApplicationInfo *application = add(appId);

228+ ApplicationInfo *application = findApplication(appId);

229+ if (application) {

230+ // the requested app is already running

231+ return application;

232+ } else {

233+ application = add(appId);

234+ }

235+

236+ // most likely not among the available ones

214 if (!application)

237 if (!application)

215− return 0;

238+ return nullptr;

216− application->setState(ApplicationInfo::Starting);

239+

240+ Q_EMIT application->focusRequested(); // we assume that an application that's starting up wants focus

217

241

218 return application;

242 return application;

219}

243}

220

244

221ApplicationInfo* ApplicationManager::add(QString appId)

245ApplicationInfo* ApplicationManager::add(QString appId)

222{

246{

223− ApplicationInfo *application = 0;

247+ ApplicationInfo *application = nullptr;

224

248

225 for (ApplicationInfo *availableApp : m_availableApplications) {

249 for (ApplicationInfo *availableApp : m_availableApplications) {

226 if (availableApp->appId() == appId) {

250 if (availableApp->appId() == appId) {

@@ -229,14 +253,18 @@ ApplicationInfo* ApplicationManager::add(QString appId)

229 }

253 }

230 }

254 }

231

255

232− if (application)

256+ if (application) {

233− add(application);

257+ if (!add(application)) {

258+ application = nullptr;

259+ }

260+ }

234

261

235 return application;

262 return application;

236}

263}

237

264

238bool ApplicationManager::stopApplication(const QString &appId)

265bool ApplicationManager::stopApplication(const QString &appId)

239{

266{

267+ DEBUG_MSG(appId);

240 ApplicationInfo *application = findApplication(appId);

268 ApplicationInfo *application = findApplication(appId);

241 if (application == nullptr)

269 if (application == nullptr)

242 return false;

270 return false;

@@ -244,8 +272,7 @@ bool ApplicationManager::stopApplication(const QString &appId)

244 if (application->appId() == focusedApplicationId()) {

272 if (application->appId() == focusedApplicationId()) {

245 unfocusCurrentApplication();

273 unfocusCurrentApplication();

246 }

274 }

247− application->setState(ApplicationInfo::Stopped);

275+ application->close();

248− remove(application);

249 return true;

276 return true;

250}

277}

251

278

@@ -264,25 +291,23 @@ bool ApplicationManager::focusApplication(const QString &appId)

264 if (application == nullptr)

291 if (application == nullptr)

265 return false;

292 return false;

266

293

267− // unfocus currently focused app

268− for (ApplicationInfo *app : m_runningApplications) {

269− if (app->focused()) {

270− app->setFocused(false);

271− }

272− }

273−

274− // focus this app

275 application->setFocused(true);

294 application->setFocused(true);

276

295

277− // move app to top of stack

278− move(m_runningApplications.indexOf(application), 0);

279− Q_EMIT focusedApplicationIdChanged();

280 return true;

296 return true;

281}

297}

282

298

283bool ApplicationManager::requestFocusApplication(const QString &appId)

299bool ApplicationManager::requestFocusApplication(const QString &appId)

284{

300{

285− QMetaObject::invokeMethod(this, "focusRequested", Qt::QueuedConnection, Q_ARG(QString, appId));

301+ ApplicationInfo *application = findApplication(appId);

302+ if (application == nullptr)

303+ return false;

304+

305+ auto surfaceList = static_cast<MirSurfaceListModel*>(application->surfaceList());

306+ if (surfaceList->count() == 0)

307+ return false;

308+

309+ surfaceList->get(0)->requestFocus();

310+

286 return true;

311 return true;

287}

312}

288

313

@@ -293,7 +318,6 @@ void ApplicationManager::unfocusCurrentApplication()

293 app->setFocused(false);

318 app->setFocused(false);

294 }

319 }

295 }

320 }

296− Q_EMIT focusedApplicationIdChanged();

297}

321}

298

322

299void ApplicationManager::buildListOfAvailableApplications()

323void ApplicationManager::buildListOfAvailableApplications()

@@ -473,3 +497,43 @@ bool ApplicationManager::isEmpty() const

473{

497{

474 return m_runningApplications.isEmpty();

498 return m_runningApplications.isEmpty();

475}

499}

500+

501+void ApplicationManager::updateFocusedApplication()

502+{

503+ ApplicationInfo *focusedApplication = nullptr;

504+ ApplicationInfo *previouslyFocusedApplication = nullptr;

505+

506+ MirSurface *surface = static_cast<MirSurface*>(MirFocusController::instance()->focusedSurface());

507+ if (surface) {

508+ focusedApplication = findApplication(surface);

509+ }

510+

511+ surface = static_cast<MirSurface*>(MirFocusController::instance()->previouslyFocusedSurface());

512+ if (surface) {

513+ previouslyFocusedApplication = findApplication(surface);

514+ }

515+

516+ if (focusedApplication != previouslyFocusedApplication) {

517+ if (focusedApplication) {

518+ DEBUG_MSG("focused " << focusedApplication->appId());

519+ Q_EMIT focusedApplication->focusedChanged(true);

520+ this->move(this->m_runningApplications.indexOf(focusedApplication), 0);

521+ }

522+ if (previouslyFocusedApplication) {

523+ DEBUG_MSG("unfocused " << previouslyFocusedApplication->appId());

524+ Q_EMIT previouslyFocusedApplication->focusedChanged(false);

525+ }

526+ Q_EMIT focusedApplicationIdChanged();

527+ }

528+}

529+

530+ApplicationInfo *ApplicationManager::findApplication(MirSurface* surface)

531+{

532+ for (ApplicationInfo *app : m_runningApplications) {

533+ auto surfaceList = static_cast<MirSurfaceListModel*>(app->surfaceList());

534+ if (surfaceList->contains(surface)) {

535+ return app;

536+ }

537+ }

538+ return nullptr;

539+}

tests/mocks/Unity/Application/ApplicationManager.h+12−8

@@ -1,5 +1,5 @@

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

@@ -26,12 +26,19 @@

26// unity-api

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

29+namespace unity {

30+ namespace shell {

31+ namespace application {

32+ class MirSurfaceInterface;

33+ }

34+ }

35+}

36+

29class QQuickItem;

37class QQuickItem;

30using namespace unity::shell::application;

38using namespace unity::shell::application;

32class ApplicationManager : public ApplicationManagerInterface {

40class ApplicationManager : public ApplicationManagerInterface {

33 Q_OBJECT

41 Q_OBJECT

34− Q_FLAGS(ExecFlags)

36 Q_PROPERTY(bool empty READ isEmpty NOTIFY emptyChanged)

43 Q_PROPERTY(bool empty READ isEmpty NOTIFY emptyChanged)

37 Q_PROPERTY(QStringList availableApplications READ availableApplications NOTIFY availableApplicationsChanged)

44 Q_PROPERTY(QStringList availableApplications READ availableApplications NOTIFY availableApplicationsChanged)

@@ -42,11 +49,6 @@ class ApplicationManager : public ApplicationManagerInterface {

43 static ApplicationManager *singleton();

50 static ApplicationManager *singleton();

45− enum MoreRoles {

46− RoleSession = RoleExemptFromLifecycle+1,

47− RoleFullscreen,

48− };

49−

50 // QAbstractItemModel methods.

52 // QAbstractItemModel methods.

51 int rowCount(const QModelIndex& parent = QModelIndex()) const override;

53 int rowCount(const QModelIndex& parent = QModelIndex()) const override;

52 QVariant data(const QModelIndex& index, int role) const override;

54 QVariant data(const QModelIndex& index, int role) const override;

@@ -79,12 +81,14 @@ class ApplicationManager : public ApplicationManagerInterface {

80 private Q_SLOTS:

82 private Q_SLOTS:

81 void onWindowCreatedTimerTimeout();

83 void onWindowCreatedTimerTimeout();

84+ void updateFocusedApplication();

83 private:

86 private:

84− void add(ApplicationInfo *application);

87+ bool add(ApplicationInfo *application);

85 void remove(ApplicationInfo* application);

88 void remove(ApplicationInfo* application);

86 void buildListOfAvailableApplications();

89 void buildListOfAvailableApplications();

87 void onWindowCreated();

90 void onWindowCreated();

91+ ApplicationInfo *findApplication(MirSurface* surface);

88 QList<ApplicationInfo*> m_runningApplications;

92 QList<ApplicationInfo*> m_runningApplications;

89 QList<ApplicationInfo*> m_availableApplications;

93 QList<ApplicationInfo*> m_availableApplications;

90 QTimer m_windowCreatedTimer;

94 QTimer m_windowCreatedTimer;

tests/mocks/Unity/Application/ApplicationTestInterface.cppdeleted−117

@@ -1,117 +0,0 @@

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−

17−#include "ApplicationInfo.h"

18−#include "ApplicationTestInterface.h"

19−#include "ApplicationManager.h"

20−#include "SessionManager.h"

21−#include "SurfaceManager.h"

22−#include "Session.h"

23−#include "MirSurface.h"

24−

25−#include <paths.h>

26−

27−#include <QtDBus/QtDBus>

28−

29−quint32 nextId = 0;

30−

31−ApplicationTestInterface::ApplicationTestInterface(QObject* parent)

32− : QDBusAbstractAdaptor(parent)

33−{

34− QDBusConnection connection = QDBusConnection::sessionBus();

35− connection.registerService("com.canonical.Unity8");

36− connection.registerObject("/com/canonical/Unity8/Mocks", parent);

37−}

38−

39−Session* ApplicationTestInterface::addChildSession(Session* existingSession, const QString& surfaceImage, bool addSurface)

40−{

41− if (!existingSession) return nullptr;

42−

43− QUrl screenshotUrl = QString("qrc:///Unity/Application/screenshots/%2@12.png")

44− .arg(qmlDirectory())

45− .arg(surfaceImage);

46−

47− Session* session = SessionManager::singleton()->createSession(

48− QString("%1-Child%2").arg(existingSession->name())

49− .arg(existingSession->childSessions()->count()),

50− screenshotUrl);

51− existingSession->addChildSession(session);

52− if (addSurface) session->createSurface();

53−

54− return session;

55−}

56−

57−void ApplicationTestInterface::removeSession(Session* existingSession)

58−{

59− qDebug() << "ApplicationTestInterface::removeSession - " << existingSession;

60−

61− if (existingSession)

62− existingSession->setLive(false);

63−}

64−

65−void ApplicationTestInterface::removeSurface(MirSurface* existingSurface)

66−{

67− qDebug() << "ApplicationTestInterface::removeSurface - " << existingSurface;

68−

69− if (existingSurface)

70− existingSurface->setLive(false);

71−}

72−

73−quint32 ApplicationTestInterface::addChildSession(const QString& appId, quint32 existingSessionId, const QString& surfaceImage, bool addSurface)

74−{

75− qDebug() << "ApplicationTestInterface::addChildSession to " << appId;

76−

77− ApplicationInfo* application = ApplicationManager::singleton()->findApplication(appId);

78− if (!application) {

79− qDebug() << "ApplicationTestInterface::addChildSession - No application found for " << appId;

80− return 0;

81− }

82−

83− Session* parentSession = nullptr;

84− if (m_childSessions.contains(existingSessionId)) {

85− parentSession = m_childSessions[existingSessionId];

86− } else if (application->session()) {

87− parentSession = application->session();

88− } else {

89− qDebug() << "ApplicationTestInterface::addChildSession - No session for " << appId << ":" << existingSessionId;

90− return 0;

91− }

92−

93− QUrl screenshotUrl = QString("qrc:///Unity/Application/screenshots/%2@12.png")

94− .arg(qmlDirectory())

95− .arg(surfaceImage);

96−

97− quint32 sessionId = ++nextId;

98− Session* session = SessionManager::singleton()->createSession(

99− QString("%1-Child%2").arg(parentSession->name())

100− .arg(parentSession->childSessions()->count()),

101− screenshotUrl);

102− parentSession->addChildSession(session);

103− if (addSurface) { session->createSurface(); }

104− m_childSessions[sessionId] = session;

105−

106− return sessionId;

107−}

108−

109−void ApplicationTestInterface::removeSession(quint32 sessionId)

110−{

111− if (!m_childSessions.contains(sessionId)) {

112− qDebug() << "ApplicationTestInterface::removeSession - No added session for " << sessionId;

113− return;

114− }

115− Session* session = m_childSessions.take(sessionId);

116− removeSession(session);

117−}

tests/mocks/Unity/Application/ApplicationTestInterface.hdeleted−45

@@ -1,45 +0,0 @@

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−

17−#ifndef APPLICATIONTESTINTERFACE_H

18−#define APPLICATIONTESTINTERFACE_H

19−

20−#include <QtDBus/QtDBus>

21−

22−class ApplicationManager;

23−class Session;

24−class MirSurface;

25−

26−class ApplicationTestInterface : public QDBusAbstractAdaptor

27−{

28− Q_OBJECT

29− Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity8.Mocks.Application")

30−public:

31− ApplicationTestInterface(QObject* parent = 0);

32−

33− Q_INVOKABLE Session* addChildSession(Session* existingSession, const QString& surfaceImage, bool addSurface);

34− Q_INVOKABLE void removeSession(Session* existingSession);

35− Q_INVOKABLE void removeSurface(MirSurface* existingSurface);

36−

37−public Q_SLOTS:

38− quint32 addChildSession(const QString& appId, quint32 existingSessionId, const QString& surfaceImage, bool addSurface);

39− void removeSession(quint32 sessionId);

40−

41−private:

42− QHash<quint32, Session*> m_childSessions;

43−};

44−

45−#endif // APPLICATIONTESTINTERFACE_H

tests/mocks/Unity/Application/CMakeLists.txt+3−4

@@ -2,14 +2,11 @@ set(FakeUnityApplicationQml_SOURCES

2 plugin.cpp

3 ApplicationInfo.cpp

4 ApplicationManager.cpp

5− ApplicationTestInterface.cpp

6 MirSurface.cpp

5 MirSurface.cpp

7 MirSurfaceItem.cpp

6 MirSurfaceItem.cpp

7+ MirSurfaceListModel.cpp

8 ObjectListModel.h

9− Session.cpp

10− SessionManager.cpp

11 SurfaceManager.cpp

9 SurfaceManager.cpp

12− SessionModel.h

13 UbuntuKeyboardInfo.cpp

10 UbuntuKeyboardInfo.cpp

14 VirtualKeyboard.cpp

11 VirtualKeyboard.cpp

15 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

12 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

@@ -17,6 +14,8 @@ set(FakeUnityApplicationQml_SOURCES

17 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

14 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

18 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

15 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

19 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceItemInterface.h

16 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceItemInterface.h

17+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

18+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirFocusControllerInterface.h

20 resources/surfaces.qrc

19 resources/surfaces.qrc

21)

20)

tests/mocks/Unity/Application/MirSurface.cpp+128−7

@@ -19,6 +19,18 @@

19#include <QDebug>

20#include <QQmlEngine>

22+#define MIRSURFACE_DEBUG 0

23+

24+#if MIRSURFACE_DEBUG

25+#define DEBUG_MSG(params) qDebug().nospace() << "MirSurface[" << (void*)this << "," << m_name << "]::" << __func__ << " " << params

26+#else

27+#define DEBUG_MSG(params) ((void)0)

28+#endif

29+

30+using namespace unity::shell::application;

31+

32+MirFocusController *MirFocusController::m_instance = nullptr;

33+

22MirSurface::MirSurface(const QString& name,

34MirSurface::MirSurface(const QString& name,

23 Mir::Type type,

35 Mir::Type type,

24 Mir::State state,

36 Mir::State state,

@@ -40,17 +52,27 @@ MirSurface::MirSurface(const QString& name,

40 , m_slowToResize(false)

52 , m_slowToResize(false)

41 , m_shellChrome(Mir::NormalChrome)

53 , m_shellChrome(Mir::NormalChrome)

42{

54{

43−// qDebug() << "MirSurface::MirSurface() " << name;

55+ DEBUG_MSG("");

56+

44 QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);

57 QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);

46 m_delayedResizeTimer.setInterval(600);

59 m_delayedResizeTimer.setInterval(600);

47 m_delayedResizeTimer.setSingleShot(true);

60 m_delayedResizeTimer.setSingleShot(true);

48 connect(&m_delayedResizeTimer, &QTimer::timeout, this, &MirSurface::applyDelayedResize);

61 connect(&m_delayedResizeTimer, &QTimer::timeout, this, &MirSurface::applyDelayedResize);

62+

63+ m_zombieTimer.setInterval(100);

64+ m_zombieTimer.setSingleShot(true);

65+ connect(&m_zombieTimer, &QTimer::timeout, this, [this](){ this->setLive(false); });

49}

66}

51MirSurface::~MirSurface()

68MirSurface::~MirSurface()

52{

69{

53−// qDebug() << "MirSurface::~MirSurface() " << name();

70+ DEBUG_MSG("");

71+

72+ auto controller = MirFocusController::instance();

73+ if (controller->focusedSurface() == this) {

74+ controller->clear();

75+ }

54}

76}

56QString MirSurface::name() const

78QString MirSurface::name() const

@@ -89,10 +111,10 @@ bool MirSurface::visible() const

111

90void MirSurface::setLive(bool live)

112void MirSurface::setLive(bool live)

91{

113{

92−// qDebug().nospace() << "MirSurface::setLive("<<live<<") " << name();

93 if (live == m_live)

114 if (live == m_live)

94 return;

115 return;

116

117+ DEBUG_MSG(live);

96 m_live = live;

118 m_live = live;

97 Q_EMIT liveChanged(live);

119 Q_EMIT liveChanged(live);

120

@@ -164,15 +186,13 @@ void MirSurface::setShellChrome(Mir::ShellChrome shellChrome)

164void MirSurface::registerView(qintptr viewId)

186void MirSurface::registerView(qintptr viewId)

165{

187{

166 m_views.insert(viewId, MirSurface::View{false});

188 m_views.insert(viewId, MirSurface::View{false});

167−// qDebug().nospace() << "MirSurface[" << name() << "]::registerView(" << viewId << ")"

168−// << " after=" << m_views.count();

189+ DEBUG_MSG(viewId << " after=" << m_views.count());

169}

190}

170

191

171void MirSurface::unregisterView(qintptr viewId)

192void MirSurface::unregisterView(qintptr viewId)

172{

193{

173−// qDebug().nospace() << "MirSurface[" << name() << "]::unregisterView(" << viewId << ")"

174−// << " after=" << m_views.count() << " live=" << m_live;

175 m_views.remove(viewId);

194 m_views.remove(viewId);

195+ DEBUG_MSG(viewId << " after=" << m_views.count() << " live=" << m_live);

176 if (!m_live && m_views.count() == 0) {

196 if (!m_live && m_views.count() == 0) {

177 deleteLater();

197 deleteLater();

178 }

198 }

@@ -215,6 +235,9 @@ void MirSurface::setActiveFocus(bool value)

215 return;

235 return;

216

236

217 m_activeFocus = value;

237 m_activeFocus = value;

238+ if (value) {

239+ MirFocusController::instance()->setFocusedSurface(this);

240+ }

218

241

219 Q_EMIT activeFocusChanged(value);

242 Q_EMIT activeFocusChanged(value);

220}

243}

@@ -288,6 +311,7 @@ bool MirSurface::isSlowToResize() const

288void MirSurface::setSlowToResize(bool value)

311void MirSurface::setSlowToResize(bool value)

289{

312{

290 if (m_slowToResize != value) {

313 if (m_slowToResize != value) {

314+ DEBUG_MSG(value);

291 m_slowToResize = value;

315 m_slowToResize = value;

292 Q_EMIT slowToResizeChanged();

316 Q_EMIT slowToResizeChanged();

293 if (!m_slowToResize && m_delayedResizeTimer.isActive()) {

317 if (!m_slowToResize && m_delayedResizeTimer.isActive()) {

@@ -344,3 +368,100 @@ void MirSurface::setHeightIncrement(int value)

344 Q_EMIT heightIncrementChanged(m_heightIncrement);

368 Q_EMIT heightIncrementChanged(m_heightIncrement);

345 }

369 }

346}

370}

371+

372+void MirSurface::raise()

373+{

374+ Q_EMIT raiseRequested();

375+}

376+

377+void MirSurface::close()

378+{

379+ DEBUG_MSG("");

380+ m_zombieTimer.start();

381+ Q_EMIT closeRequested();

382+}

383+

384+void MirSurface::createPromptSurface()

385+{

386+ QStringList screenshotIds = {"gallery", "map", "facebook", "camera", "browser", "music", "twitter"};

387+ int i = rand() % screenshotIds.count();

388+

389+ QUrl screenshotUrl = QString("qrc:///Unity/Application/screenshots/%1@12.png")

390+ .arg(screenshotIds[i]);

391+

392+ auto surface = new MirSurface(QString("prompt foo"),

393+ Mir::NormalType,

394+ Mir::RestoredState,

395+ screenshotUrl);

396+

397+ m_promptSurfaceList.appendSurface(surface);

398+}

399+

400+MirSurfaceListInterface* MirSurface::promptSurfaceList()

401+{

402+ return &m_promptSurfaceList;

403+}

404+

405+void MirSurface::requestFocus()

406+{

407+ DEBUG_MSG("");

408+ Q_EMIT focusRequested();

409+}

410+

411+void MirSurface::setFocused(bool value)

412+{

413+ DEBUG_MSG(value);

414+ auto controller = MirFocusController::instance();

415+ if (value) {

416+ controller->setFocusedSurface(this);

417+ } else if (controller->focusedSurface() == this) {

418+ controller->setFocusedSurface(nullptr);

419+ }

420+}

421+

422+bool MirSurface::focused() const

423+{

424+ return MirFocusController::instance()->focusedSurface() == this;

425+}

426+

427+#if MIRSURFACE_DEBUG

428+#undef DEBUG_MSG

429+#define DEBUG_MSG(params) qDebug().nospace() << "MirFocusController::" << __func__ << " " << params

430+#endif

431+

432+void MirFocusController::setFocusedSurface(MirSurfaceInterface *surface)

433+{

434+ if (m_focusedSurface == surface) {

435+ return;

436+ }

437+ DEBUG_MSG("MirSurface[" << (void*)surface << "," << (surface?surface->name():"") << "]");

438+

439+ m_previouslyFocusedSurface = m_focusedSurface;

440+ m_focusedSurface = surface;

441+

442+ if (m_previouslyFocusedSurface != m_focusedSurface) {

443+ Q_EMIT focusedSurfaceChanged();

444+ }

445+

446+ if (m_previouslyFocusedSurface) {

447+ Q_EMIT m_previouslyFocusedSurface->focusedChanged(false);

448+ }

449+

450+ if (m_focusedSurface) {

451+ Q_EMIT m_focusedSurface->focusedChanged(true);

452+ }

453+}

454+

455+MirFocusController* MirFocusController::instance()

456+{

457+ if (!m_instance) {

458+ m_instance = new MirFocusController;

459+ }

460+ return m_instance;

461+}

462+

463+void MirFocusController::clear()

464+{

465+ m_focusedSurface = m_previouslyFocusedSurface = nullptr;

466+ Q_EMIT focusedSurfaceChanged();

467+}

tests/mocks/Unity/Application/MirSurface.h+49−5

@@ -23,8 +23,30 @@

23#include <QHash>

25// unity-api

26+#include <unity/shell/application/MirFocusControllerInterface.h>

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

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

29+#include "MirSurfaceListModel.h"

30+

31+class MirSurface;

32+

33+class MirFocusController : public unity::shell::application::MirFocusControllerInterface

34+{

35+ Q_OBJECT

36+public:

37+ MirFocusController(){}

38+ static MirFocusController* instance();

39+

40+ void setFocusedSurface(unity::shell::application::MirSurfaceInterface *surface) override;

41+ unity::shell::application::MirSurfaceInterface* focusedSurface() const override { return m_focusedSurface; }

42+ unity::shell::application::MirSurfaceInterface* previouslyFocusedSurface() { return m_previouslyFocusedSurface; }

43+ void clear();

44+private:

45+ static MirFocusController *m_instance;

46+ unity::shell::application::MirSurfaceInterface* m_previouslyFocusedSurface{nullptr};

47+ unity::shell::application::MirSurfaceInterface* m_focusedSurface{nullptr};

48+};

49+

28class MirSurface : public unity::shell::application::MirSurfaceInterface

50class MirSurface : public unity::shell::application::MirSurfaceInterface

29{

51{

30 Q_OBJECT

52 Q_OBJECT

@@ -79,17 +101,22 @@ public:

101

80 Mir::ShellChrome shellChrome() const override;

102 Mir::ShellChrome shellChrome() const override;

103

104+ bool focused() const override;

105+

106+ Q_INVOKABLE void requestFocus() override;

107+

108+ Q_INVOKABLE void close() override;

109+

110+ unity::shell::application::MirSurfaceListInterface* promptSurfaceList() override;

111+

112+ Q_INVOKABLE void raise() override;

113+

82 ////

114 ////

83 // API for tests

115 // API for tests

116

85 Q_INVOKABLE void setLive(bool live);

117 Q_INVOKABLE void setLive(bool live);

86 Q_INVOKABLE void setShellChrome(Mir::ShellChrome shellChrome);

118 Q_INVOKABLE void setShellChrome(Mir::ShellChrome shellChrome);

119

88− void registerView(qintptr viewId);

89− void unregisterView(qintptr viewId);

90− void setViewVisibility(qintptr viewId, bool visible);

91− int viewCount() const { return m_views.count(); }

92−

93 int width() const;

120 int width() const;

94 int height() const;

121 int height() const;

122

@@ -103,6 +130,8 @@ public:

103 Q_INVOKABLE void setWidthIncrement(int);

130 Q_INVOKABLE void setWidthIncrement(int);

104 Q_INVOKABLE void setHeightIncrement(int);

131 Q_INVOKABLE void setHeightIncrement(int);

105

132

133+ Q_INVOKABLE void createPromptSurface();

134+

106 /////

135 /////

107 // internal mock stuff

136 // internal mock stuff

108

137

@@ -114,7 +143,16 @@ public:

114 bool activeFocus() const;

143 bool activeFocus() const;

115 void setActiveFocus(bool);

144 void setActiveFocus(bool);

116

145

146+ void registerView(qintptr viewId);

147+ void unregisterView(qintptr viewId);

148+ void setViewVisibility(qintptr viewId, bool visible);

149+ int viewCount() const { return m_views.count(); }

150+

151+ void setFocused(bool value);

152+

117Q_SIGNALS:

153Q_SIGNALS:

154+ ////

155+ // API for tests

118 void widthChanged();

156 void widthChanged();

119 void heightChanged();

157 void heightChanged();

120 void slowToResizeChanged();

158 void slowToResizeChanged();

@@ -123,6 +161,8 @@ Q_SIGNALS:

123 // internal mock stuff

161 // internal mock stuff

124 void screenshotUrlChanged(QUrl);

162 void screenshotUrlChanged(QUrl);

125 void activeFocusChanged(bool);

163 void activeFocusChanged(bool);

164+ void raiseRequested();

165+ void closeRequested();

126

166

127private Q_SLOTS:

167private Q_SLOTS:

128 void applyDelayedResize();

168 void applyDelayedResize();

@@ -135,6 +175,7 @@ private:

135 const Mir::Type m_type;

175 const Mir::Type m_type;

136 Mir::State m_state;

176 Mir::State m_state;

137 Mir::OrientationAngle m_orientationAngle;

177 Mir::OrientationAngle m_orientationAngle;

178+

138 QUrl m_screenshotUrl;

179 QUrl m_screenshotUrl;

139 QUrl m_qmlFilePath;

180 QUrl m_qmlFilePath;

140 bool m_live;

181 bool m_live;

@@ -158,11 +199,14 @@ private:

158 QSize m_pendingResize;

199 QSize m_pendingResize;

159

200

160 Mir::ShellChrome m_shellChrome;

201 Mir::ShellChrome m_shellChrome;

202+ MirSurfaceListModel m_promptSurfaceList;

161

203

162 struct View {

204 struct View {

163 bool visible;

205 bool visible;

164 };

206 };

165 QHash<qintptr, View> m_views;

207 QHash<qintptr, View> m_views;

208+

209+ QTimer m_zombieTimer;

166};

210};

167

211

168#endif // MOCK_MIR_SURFACE_H

212#endif // MOCK_MIR_SURFACE_H

tests/mocks/Unity/Application/MirSurfaceItem.cpp+13−7

@@ -1,5 +1,5 @@

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

@@ -29,6 +29,14 @@

30using namespace unity::shell::application;

32+#define MIRSURFACEITEM_DEBUG 0

33+

34+#if MIRSURFACEITEM_DEBUG

35+#define DEBUG_MSG(params) qDebug().nospace() << "MirSurfaceItem::" << __func__ << " " << params

36+#else

37+#define DEBUG_MSG(params) ((void)0)

38+#endif

39+

32MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)

40MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)

33 : MirSurfaceItemInterface(parent)

41 : MirSurfaceItemInterface(parent)

34 , m_qmlSurface(nullptr)

42 , m_qmlSurface(nullptr)

@@ -41,7 +49,7 @@ MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)

41 , m_mousePressCount(0)

49 , m_mousePressCount(0)

42 , m_mouseReleaseCount(0)

50 , m_mouseReleaseCount(0)

43{

51{

44−// qDebug() << "MirSurfaceItem::MirSurfaceItem() " << (void*)(this) << name();

52+ DEBUG_MSG((void*)(this) << name());

45 setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton |

53 setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton |

46 Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::ExtraButton3 | Qt::ExtraButton4 |

54 Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::ExtraButton3 | Qt::ExtraButton4 |

47 Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |

55 Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |

@@ -53,7 +61,7 @@ MirSurfaceItem::MirSurfaceItem(QQuickItem *parent)

54MirSurfaceItem::~MirSurfaceItem()

62MirSurfaceItem::~MirSurfaceItem()

55{

63{

56−// qDebug() << "MirSurfaceItem::~MirSurfaceItem() " << (void*)(this) << name();

64+ DEBUG_MSG((void*)(this) << name());

57 setSurface(nullptr);

65 setSurface(nullptr);

58}

66}

@@ -150,7 +158,7 @@ void MirSurfaceItem::onComponentStatusChanged(QQmlComponent::Status status)

150

158

151void MirSurfaceItem::createQmlContentItem()

159void MirSurfaceItem::createQmlContentItem()

152{

160{

153−// qDebug() << "MirSurfaceItem::createQmlContentItem()";

161+ DEBUG_MSG("");

154

162

155 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

163 m_qmlItem = qobject_cast<QQuickItem*>(m_qmlContentComponent->create());

156 m_qmlItem->setParentItem(this);

164 m_qmlItem->setParentItem(this);

@@ -213,9 +221,7 @@ void MirSurfaceItem::mouseReleaseEvent(QMouseEvent * event)

213

221

214void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

222void MirSurfaceItem::setSurface(MirSurfaceInterface* surface)

215{

223{

216−// qDebug().nospace() << "MirSurfaceItem::setSurface() this=" << (void*)(this)

217−// << " name=" << name()

218−// << " surface=" << surface;

224+ DEBUG_MSG("this=" << (void*)(this) << " name=" << name() << " surface=" << surface);

219

225

220 if (m_qmlSurface == surface) {

226 if (m_qmlSurface == surface) {

221 return;

227 return;

tests/mocks/Unity/Application/MirSurfaceListModel.cppnew file+121

@@ -0,0 +1,121 @@

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+

17+#include "MirSurfaceListModel.h"

18+#include "ApplicationInfo.h"

19+

20+#include "MirSurface.h"

21+

22+#define MIRSURFACELISTMODEL_DEBUG 0

23+

24+#ifdef MIRSURFACELISTMODEL_DEBUG

25+#define DEBUG_MSG(params) qDebug().nospace() << "MirSurfaceListModel::" << __func__ << " " << params

26+#else

27+#define DEBUG_MSG(params) ((void)0)

28+#endif

29+

30+using namespace unity::shell::application;

31+

32+MirSurfaceListModel::MirSurfaceListModel(QObject *parent) :

33+ MirSurfaceListInterface(parent)

34+{

35+}

36+

37+int MirSurfaceListModel::rowCount(const QModelIndex &parent) const

38+{

39+ return !parent.isValid() ? m_surfaceList.size() : 0;

40+}

41+

42+QVariant MirSurfaceListModel::data(const QModelIndex& index, int role) const

43+{

44+ if (index.row() < 0 || index.row() >= m_surfaceList.size())

45+ return QVariant();

46+

47+ if (role == SurfaceRole) {

48+ MirSurface *surface = m_surfaceList.at(index.row());

49+ return QVariant::fromValue(static_cast<unity::shell::application::MirSurfaceInterface*>(surface));

50+ } else {

51+ return QVariant();

52+ }

53+}

54+

55+void MirSurfaceListModel::raise(MirSurface *surface)

56+{

57+ int i = m_surfaceList.indexOf(surface);

58+ if (i != -1) {

59+ moveSurface(i, 0);

60+ }

61+}

62+

63+void MirSurfaceListModel::appendSurface(MirSurface *surface)

64+{

65+ beginInsertRows(QModelIndex(), m_surfaceList.size(), m_surfaceList.size());

66+ m_surfaceList.append(surface);

67+ connectSurface(surface);

68+ endInsertRows();

69+ Q_EMIT countChanged();

70+}

71+

72+void MirSurfaceListModel::connectSurface(MirSurface *surface)

73+{

74+ connect(surface, &MirSurface::raiseRequested, this, [this, surface](){ this->raise(surface); });

75+ connect(surface, &QObject::destroyed, this, [this, surface](){ this->removeSurface(surface); });

76+}

77+

78+void MirSurfaceListModel::removeSurface(MirSurface *surface)

79+{

80+ int i = m_surfaceList.indexOf(surface);

81+ if (i != -1) {

82+ beginRemoveRows(QModelIndex(), i, i);

83+ m_surfaceList.removeAt(i);

84+ endRemoveRows();

85+ Q_EMIT countChanged();

86+ }

87+}

88+

89+void MirSurfaceListModel::moveSurface(int from, int to)

90+{

91+ if (from == to) return;

92+

93+ if (from >= 0 && from < m_surfaceList.size() && to >= 0 && to < m_surfaceList.size()) {

94+ QModelIndex parent;

95+ /* When moving an item down, the destination index needs to be incremented

96+ by one, as explained in the documentation:

97+ http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */

98+

99+ beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));

100+ m_surfaceList.move(from, to);

101+ endMoveRows();

102+ }

103+}

104+

105+MirSurfaceInterface *MirSurfaceListModel::get(int index)

106+{

107+ if (index >=0 && index < m_surfaceList.count()) {

108+ return m_surfaceList[index];

109+ } else {

110+ return nullptr;

111+ }

112+}

113+

114+const MirSurfaceInterface *MirSurfaceListModel::get(int index) const

115+{

116+ if (index >=0 && index < m_surfaceList.count()) {

117+ return m_surfaceList.at(index);

118+ } else {

119+ return nullptr;

120+ }

121+}

tests/mocks/Unity/Application/MirSurfaceListModel.hnew file+56

@@ -0,0 +1,56 @@

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+

17+#ifndef MIRSURFACELISTMODEL_H

18+#define MIRSURFACELISTMODEL_H

19+

20+// unity-api

21+#include <unity/shell/application/MirSurfaceListInterface.h>

22+

23+#include <QAbstractListModel>

24+#include <QList>

25+

26+class MirSurface;

27+

28+class MirSurfaceListModel : public unity::shell::application::MirSurfaceListInterface

29+{

30+ Q_OBJECT

31+public:

32+ explicit MirSurfaceListModel(QObject *parent = 0);

33+

34+ Q_INVOKABLE unity::shell::application::MirSurfaceInterface *get(int index) override;

35+ const unity::shell::application::MirSurfaceInterface *get(int index) const;

36+

37+ // QAbstractItemModel methods

38+ int rowCount(const QModelIndex &parent = QModelIndex()) const override;

39+ QVariant data(const QModelIndex& index, int role) const override;

40+

41+ void appendSurface(MirSurface *surface);

42+ void removeSurface(MirSurface *surface);

43+

44+ bool contains(MirSurface *surface) const { return m_surfaceList.contains(surface); }

45+

46+private:

47+ void raise(MirSurface *surface);

48+ void moveSurface(int from, int to);

49+ void connectSurface(MirSurface *surface);

50+

51+ QList<MirSurface*> m_surfaceList;

52+};

53+

54+Q_DECLARE_METATYPE(MirSurfaceListModel*)

55+

56+#endif // MIRSURFACELISTMODEL_H

tests/mocks/Unity/Application/ObjectListModel.h+2

@@ -20,6 +20,8 @@

20// Qt

21#include <QAbstractListModel>

23+#include <QDebug>

24+

23template<class TYPE>

25template<class TYPE>

24class ObjectListModel : public QAbstractListModel

26class ObjectListModel : public QAbstractListModel

25{

27{

tests/mocks/Unity/Application/Session.cppdeleted−209

@@ -1,209 +0,0 @@

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−

17−#include "Session.h"

18−#include "ApplicationInfo.h"

19−#include "SessionManager.h"

20−#include "SurfaceManager.h"

21−

22−#include <QPainter>

23−#include <QQmlEngine>

24−#include <QTimer>

25−

26−Session::Session(const QString &name,

27− const QUrl& screenshot,

28− QObject *parent)

29− : QObject(parent)

30− , m_name(name)

31− , m_live(true)

32− , m_screenshot(screenshot)

33− , m_application(nullptr)

34− , m_surface(nullptr)

35− , m_parentSession(nullptr)

36− , m_children(new SessionModel(this))

37− , m_fullscreen(false)

38−{

39−// qDebug() << "Session::Session() " << this->name();

40−

41− QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);

42−}

43−

44−Session::~Session()

45−{

46−// qDebug() << "Session::~Session() " << name();

47−

48− QList<Session*> children(m_children->list());

49− for (Session* child : children) {

50− delete child;

51− }

52− if (m_parentSession) {

53− m_parentSession->removeChildSession(this);

54− }

55− if (m_application) {

56− m_application->setSession(nullptr);

57− }

58− delete m_children;

59−

60− if (m_surface) {

61− if (m_surface->viewCount() == 0) {

62− delete m_surface;

63− } else {

64− m_surface->setLive(false);

65− }

66− }

67−}

68−

69−void Session::release()

70−{

71−// qDebug() << "Session::release " << name();

72− deleteLater();

73−}

74−

75−void Session::updateFullscreenProperty()

76−{

77− if (m_surfaces.rowCount() > 0) {

78− // TODO: Figure out something better

79− setFullscreen(lastSurface()->state() == Mir::FullscreenState);

80− } else {

81− // Keep the current value of the fullscreen property until we get a new

82− // surface

83− }

84−}

85−

86−void Session::setFullscreen(bool fullscreen)

87−{

88− if (m_fullscreen != fullscreen) {

89− m_fullscreen = fullscreen;

90− Q_EMIT fullscreenChanged(m_fullscreen);

91− }

92−}

93−

94−void Session::setApplication(ApplicationInfo* application)

95−{

96− if (m_application == application)

97− return;

98−

99− m_application = application;

100− Q_EMIT applicationChanged(application);

101−}

102−

103−void Session::appendSurface(MirSurface* surface)

104−{

105− qDebug() << "Session::appendSurface - session=" << name() << "surface=" << surface;

106−

107− m_surfaces.insert(m_surfaces.rowCount(), surface);

108−

109− connect(surface, &MirSurfaceInterface::stateChanged, this, &Session::updateFullscreenProperty);

110− connect(surface, &QObject::destroyed,

111− this, [this, surface]() { this->removeSurface(surface); });

112−

113− Q_EMIT lastSurfaceChanged(surface);

114− Q_EMIT surfaceAdded(surface);

115−

116− updateFullscreenProperty();

117−}

118−

119−void Session::removeSurface(MirSurface* surface)

120−{

121− disconnect(surface, nullptr, this, nullptr);

122− if (m_surfaces.contains(surface)) {

123− m_surfaces.remove(surface);

124− }

125−

126− updateFullscreenProperty();

127−}

128−

129−void Session::setScreenshot(const QUrl& screenshot)

130−{

131− if (screenshot != m_screenshot) {

132− m_screenshot = screenshot;

133− if (m_surface) {

134− m_surface->setScreenshotUrl(m_screenshot);

135− }

136− }

137−}

138−

139−void Session::setLive(bool live)

140−{

141− if (m_live != live) {

142− m_live = live;

143− Q_EMIT liveChanged(m_live);

144− }

145−}

146−

147−void Session::setParentSession(Session* session)

148−{

149− if (m_parentSession == session || session == this)

150− return;

151−

152− m_parentSession = session;

153− Q_EMIT parentSessionChanged(session);

154−}

155−

156−void Session::createSurface()

157−{

158− if (m_surface) return;

159−

160− appendSurface(SurfaceManager::singleton()->createSurface(name(),

161− Mir::NormalType,

162− m_application && m_application->fullscreen() ? Mir::FullscreenState :

163− Mir::MaximizedState,

164− m_screenshot));

165−}

166−

167−void Session::addChildSession(Session* session)

168−{

169− insertChildSession(m_children->rowCount(), session);

170−}

171−

172−void Session::insertChildSession(uint index, Session* session)

173−{

174− qDebug() << "Session::insertChildSession - " << session->name() << " to " << name() << " @ " << index;

175−

176− session->setParentSession(this);

177− m_children->insert(index, session);

178− SessionManager::singleton()->registerSession(session);

179−}

180−

181−void Session::removeChildSession(Session* session)

182−{

183− qDebug() << "Session::removeChildSession - " << session->name() << " from " << name();

184−

185− if (m_children->contains(session)) {

186− m_children->remove(session);

187− session->setParentSession(nullptr);

188− Q_EMIT session->deregister();

189− }

190−}

191−

192−SessionModel* Session::childSessions() const

193−{

194− return m_children;

195−}

196−

197−ObjectListModel<MirSurface>* Session::surfaces() const

198−{

199− return const_cast<ObjectListModel<MirSurface>*>(&m_surfaces);

200−}

201−

202−MirSurface *Session::lastSurface() const

203−{

204− if (m_surfaces.rowCount() > 0) {

205− return m_surfaces.list().last();

206− } else {

207− return nullptr;

208− }

209−}

tests/mocks/Unity/Application/Session.hdeleted−104

@@ -1,104 +0,0 @@

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−

17−#ifndef SESSION_H

18−#define SESSION_H

19−

20−#include "ObjectListModel.h"

21−#include "SessionModel.h"

22−

23−#include <QQuickItem>

24−

25−class ApplicationInfo;

26−class MirSurface;

27−

28−class Session : public QObject

29−{

30− Q_OBJECT

31− Q_PROPERTY(QString name READ name CONSTANT)

32− Q_PROPERTY(MirSurface* lastSurface READ lastSurface NOTIFY lastSurfaceChanged)

33− Q_PROPERTY(ObjectListModel<MirSurface>* surfaces READ surfaces CONSTANT)

34− Q_PROPERTY(ApplicationInfo* application READ application NOTIFY applicationChanged)

35− Q_PROPERTY(Session* parentSession READ parentSession NOTIFY parentSessionChanged DESIGNABLE false)

36− Q_PROPERTY(SessionModel* childSessions READ childSessions DESIGNABLE false CONSTANT)

37− Q_PROPERTY(bool live READ live NOTIFY liveChanged)

38−

39−public:

40− explicit Session(const QString &name,

41− const QUrl& screenshot,

42− QObject *parent = 0);

43− ~Session();

44−

45− Q_INVOKABLE void release();

46−

47− //getters

48− QString name() const { return m_name; }

49− bool live() const { return m_live; }

50− bool fullscreen() const { return m_fullscreen; }

51− ApplicationInfo* application() const { return m_application; }

52− MirSurface *lastSurface() const;

53− ObjectListModel<MirSurface>* surfaces() const;

54− Session* parentSession() const { return m_parentSession; }

55−

56− void setApplication(ApplicationInfo* item);

57− void appendSurface(MirSurface* surface);

58− void removeSurface(MirSurface* surface);

59− void setScreenshot(const QUrl& m_screenshot);

60− void setLive(bool live);

61− void setFullscreen(bool fullscreen);

62−

63− Q_INVOKABLE void addChildSession(Session* session);

64− void insertChildSession(uint index, Session* session);

65− Q_INVOKABLE void removeChildSession(Session* session);

66−

67−Q_SIGNALS:

68− void applicationChanged(ApplicationInfo*);

69− void parentSessionChanged(Session*);

70− void liveChanged(bool live);

71− void surfaceAdded(MirSurface *surface);

72− void lastSurfaceChanged(MirSurface *surface);

73− void fullscreenChanged(bool fullscreen);

74−

75− // internal mock use

76− void deregister();

77−

78−public Q_SLOTS:

79− Q_INVOKABLE void createSurface();

80−

81−private Q_SLOTS:

82− void updateFullscreenProperty();

83−

84−private:

85− SessionModel* childSessions() const;

86− void setParentSession(Session* session);

87−

88− QString m_name;

89− bool m_live;

90− QUrl m_screenshot;

91− ApplicationInfo* m_application;

92− MirSurface* m_surface;

93− Session* m_parentSession;

94− SessionModel* m_children;

95− ObjectListModel<MirSurface> m_surfaces;

96− bool m_fullscreen;

97−

98− friend class ApplicationTestInterface;

99−};

100−

101−Q_DECLARE_METATYPE(Session*)

102−Q_DECLARE_METATYPE(ObjectListModel<MirSurface>*)

103−

104−#endif // SESSION_H

tests/mocks/Unity/Application/SessionManager.cppdeleted−55

@@ -1,55 +0,0 @@

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−

17−#include "SessionManager.h"

18−

19−#include "Session.h"

20−

21−SessionManager *SessionManager::the_session_manager = nullptr;

22−

23−SessionManager *SessionManager::singleton()

24−{

25− if (!the_session_manager) {

26− the_session_manager = new SessionManager();

27− }

28− return the_session_manager;

29−}

30−

31−SessionManager::SessionManager(QObject *parent) :

32− QObject(parent)

33−{

34−}

35−

36−

37−Session *SessionManager::createSession(const QString& name,

38− const QUrl& screenshot)

39−{

40− Session* session = new Session(name, screenshot);

41− Q_EMIT sessionStarting(session);

42− return session;

43−}

44−

45−void SessionManager::registerSession(Session *session)

46−{

47− connect(session, &Session::deregister, this, [this] {

48− Session* session = qobject_cast<Session*>(sender());

49−

50− disconnect(session, 0, this, 0);

51−

52− session->setLive(false);

53− Q_EMIT sessionStopping(session);

54− });

55−}

tests/mocks/Unity/Application/SessionModel.hdeleted−35

@@ -1,35 +0,0 @@

1−/*

3− *

4− * This program is free software: you can redistribute it and/or modify it under

5− * the terms of the GNU Lesser General Public License version 3, as published by

6− * the Free Software Foundation.

7− *

8− * This program is distributed in the hope that it will be useful, but WITHOUT

9− * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,

10− * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

11− * 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−

17−#ifndef SESSIONMODEL_H

18−#define SESSIONMODEL_H

19−

20−// Local

21−#include "ObjectListModel.h"

22−

23−class Session;

24−class SessionModel: public ObjectListModel<Session>

25−{

26− Q_OBJECT

27−public:

28− SessionModel(QObject *parent = 0): ObjectListModel(parent) {}

29−

30− Q_INVOKABLE int count() const { return rowCount(); }

31−};

32−

33−Q_DECLARE_METATYPE(SessionModel*)

34−

35−#endif // SESSIONMODEL_H

tests/mocks/Unity/Application/SurfaceManager.cpp+5−4

@@ -1,5 +1,5 @@

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

@@ -16,6 +16,7 @@

17#include "SurfaceManager.h"

19+#include "ApplicationInfo.h"

19#include "VirtualKeyboard.h"

20#include "VirtualKeyboard.h"

21#include <paths.h>

22#include <paths.h>

@@ -44,9 +45,9 @@ SurfaceManager::SurfaceManager(QObject *parent) :

44}

45}

46MirSurface *SurfaceManager::createSurface(const QString& name,

47MirSurface *SurfaceManager::createSurface(const QString& name,

47− Mir::Type type,

48+ Mir::Type type,

48− Mir::State state,

49+ Mir::State state,

49− const QUrl& screenshot)

50+ const QUrl& screenshot)

50{

51{

51 MirSurface* surface = new MirSurface(name, type, state, screenshot);

52 MirSurface* surface = new MirSurface(name, type, state, screenshot);

52 connect(surface, &QObject::destroyed, this, [this](QObject *obj) {

53 connect(surface, &QObject::destroyed, this, [this](QObject *obj) {

tests/mocks/Unity/Application/SurfaceManager.h+2

@@ -22,6 +22,8 @@

22#include "MirSurface.h"

23#include "VirtualKeyboard.h"

25+class ApplicationInfo;

26+

25class SurfaceManager : public QObject

27class SurfaceManager : public QObject

26{

28{

27 Q_OBJECT

29 Q_OBJECT

tests/mocks/Unity/Application/plugin.cpp+5−27

@@ -17,11 +17,8 @@

17#include "plugin.h"

18#include "ApplicationInfo.h"

19#include "ApplicationManager.h"

20−#include "Session.h"

21#include "MirSurfaceItem.h"

20#include "MirSurfaceItem.h"

22#include "SurfaceManager.h"

21#include "SurfaceManager.h"

23−#include "SessionManager.h"

24−#include "ApplicationTestInterface.h"

25#include "UbuntuKeyboardInfo.h"

22#include "UbuntuKeyboardInfo.h"

27// unity-api

24// unity-api

@@ -42,50 +39,34 @@ static QObject* surfaceManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEng

42 return SurfaceManager::singleton();

39 return SurfaceManager::singleton();

43}

40}

45−static QObject* sessionManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {

46− Q_UNUSED(engine);

47− Q_UNUSED(scriptEngine);

48− return SessionManager::singleton();

49−}

50−

51static QObject* ubuntuKeyboardInfoSingleton(QQmlEngine*, QJSEngine*) {

42static QObject* ubuntuKeyboardInfoSingleton(QQmlEngine*, QJSEngine*) {

52 return UbuntuKeyboardInfo::singleton();

43 return UbuntuKeyboardInfo::singleton();

53}

44}

55−

56−ApplicationTestInterface* s_appTestInterface = nullptr;

57−

58−static QObject* applicationTestInterface(QQmlEngine* engine, QJSEngine* scriptEngine) {

46+static QObject* mirFocusControllerSingleton(QQmlEngine*, QJSEngine*)

59− Q_UNUSED(engine);

47+{

60− Q_UNUSED(scriptEngine);

48+ return MirFocusController::instance();

61− if (!s_appTestInterface) {

62− s_appTestInterface = new ApplicationTestInterface(engine);

63− }

64− return s_appTestInterface;

65}

49}

67void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

51void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

68{

52{

69− qRegisterMetaType<Session*>("Session*");

70 qRegisterMetaType<ApplicationInfo*>("ApplicationInfo*");

53 qRegisterMetaType<ApplicationInfo*>("ApplicationInfo*");

71− qRegisterMetaType<SessionModel*>("SessionModel*");

72 qRegisterMetaType<unity::shell::application::MirSurfaceInterface*>("unity::shell::application::MirSurfaceInterface*");

54 qRegisterMetaType<unity::shell::application::MirSurfaceInterface*>("unity::shell::application::MirSurfaceInterface*");

55+ qRegisterMetaType<unity::shell::application::MirSurfaceListInterface*>("unity::shell::application::MirSurfaceListInterface*");

73 qRegisterMetaType<Mir::Type>("Mir::Type");

56 qRegisterMetaType<Mir::Type>("Mir::Type");

74 qRegisterMetaType<Mir::State>("Mir::State");

57 qRegisterMetaType<Mir::State>("Mir::State");

76 qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");

59 qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");

77 qmlRegisterUncreatableType<unity::shell::application::ApplicationInfoInterface>(uri, 0, 1, "ApplicationInfoInterface", "Abstract interface. Cannot be created in QML");

60 qmlRegisterUncreatableType<unity::shell::application::ApplicationInfoInterface>(uri, 0, 1, "ApplicationInfoInterface", "Abstract interface. Cannot be created in QML");

78− qmlRegisterUncreatableType<Session>(uri, 0, 1, "Session", "Session can't be instantiated from QML");

79 qmlRegisterUncreatableType<MirSurface>(uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");

61 qmlRegisterUncreatableType<MirSurface>(uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");

80 qmlRegisterUncreatableType<unity::shell::application::MirSurfaceInterface>(

62 qmlRegisterUncreatableType<unity::shell::application::MirSurfaceInterface>(

81 uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");

63 uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");

64+ qmlRegisterSingletonType<MirFocusController>(uri, 0, 1, "MirFocusController", mirFocusControllerSingleton);

82 qmlRegisterType<MirSurfaceItem>(uri, 0, 1, "MirSurfaceItem");

65 qmlRegisterType<MirSurfaceItem>(uri, 0, 1, "MirSurfaceItem");

83 qmlRegisterType<ApplicationInfo>(uri, 0, 1, "ApplicationInfo");

66 qmlRegisterType<ApplicationInfo>(uri, 0, 1, "ApplicationInfo");

85 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

68 qmlRegisterSingletonType<ApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerSingleton);

86 qmlRegisterSingletonType<SurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);

69 qmlRegisterSingletonType<SurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);

87− qmlRegisterSingletonType<SessionManager>(uri, 0, 1, "SessionManager", sessionManagerSingleton);

88− qmlRegisterSingletonType<ApplicationTestInterface>(uri, 0, 1, "ApplicationTest", applicationTestInterface);

89 qmlRegisterSingletonType<UbuntuKeyboardInfo>(uri, 0, 1, "UbuntuKeyboardInfo", ubuntuKeyboardInfoSingleton);

70 qmlRegisterSingletonType<UbuntuKeyboardInfo>(uri, 0, 1, "UbuntuKeyboardInfo", ubuntuKeyboardInfoSingleton);

91 qmlRegisterUncreatableType<Mir>(uri, 0, 1, "Mir", "Mir provides enum values, it can't be instantiated");

72 qmlRegisterUncreatableType<Mir>(uri, 0, 1, "Mir", "Mir provides enum values, it can't be instantiated");

@@ -94,7 +75,4 @@ void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)

94void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

75void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

95{

76{

96 QQmlExtensionPlugin::initializeEngine(engine, uri);

77 QQmlExtensionPlugin::initializeEngine(engine, uri);

97−

98− // make sure we initialise our test interface.

99− applicationTestInterface(engine, nullptr);

100}

78}

tests/mocks/Utils/CMakeLists.txt+4

@@ -22,6 +22,10 @@ set(QMLPLUGIN_SRC

22 ${CMAKE_SOURCE_DIR}/plugins/Utils/deviceconfigparser.cpp

23 ${CMAKE_SOURCE_DIR}/plugins/Utils/globalfunctions.cpp

24 ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h

25+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h

26+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h

27+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h

28+ ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h

25 constants.cpp

29 constants.cpp

26 plugin.cpp

30 plugin.cpp

27 windowstatestorage.cpp

31 windowstatestorage.cpp

tests/mocks/Utils/plugin.cpp+1−1

@@ -1,5 +1,5 @@

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

tests/plugins/Unity/Launcher/launchermodeltest.cpp+1

@@ -64,6 +64,7 @@ public:

64 void setExemptFromLifecycle(bool) override {}

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

66 void setInitialSurfaceSize(const QSize &) override {}

67+ MirSurfaceListInterface* surfaceList() override { return nullptr; }

68 // Methods used for mocking (not in the interface)

69 // Methods used for mocking (not in the interface)

69 void setFocused(bool focused) { m_focused = focused; Q_EMIT focusedChanged(focused); }

70 void setFocused(bool focused) { m_focused = focused; Q_EMIT focusedChanged(focused); }

tests/qmltests/CMakeLists.txt−1

@@ -88,7 +88,6 @@ add_unity8_qmltest(Stages DesktopStage)

88add_unity8_qmltest(Stages PhoneStage)

89add_unity8_qmltest(Stages SpreadDelegate)

90add_unity8_qmltest(Stages SurfaceContainer)

91−add_unity8_qmltest(Stages SessionContainer)

92add_unity8_qmltest(Stages TabletStage)

91add_unity8_qmltest(Stages TabletStage)

93add_unity8_qmltest(Stages WindowResizeArea)

92add_unity8_qmltest(Stages WindowResizeArea)

94add_unity8_qmltest(Stages Splash)

93add_unity8_qmltest(Stages Splash)

tests/qmltests/Stages/ApplicationCheckBox.qml+104−58

@@ -1,5 +1,5 @@

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

@@ -19,11 +19,17 @@ import QtQuick.Layouts 1.1

19import Ubuntu.Components 1.3

20import Unity.Application 0.1

22−RowLayout {

22+Column {

23 id: root

24 property string appId

25 property bool checked: false

27+ function createSurface() {

28+ if (d.application) {

29+ d.application.createSurface();

30+ }

31+ }

32+

27 enabled: appId !== "unity8-dash"

33 enabled: appId !== "unity8-dash"

29 onCheckedChanged: {

35 onCheckedChanged: {

@@ -38,77 +44,117 @@ RowLayout {

38 d.bindGuard = false;

44 d.bindGuard = false;

39 }

45 }

47+ RowLayout {

48+

41− QtObject {

49+ QtObject {

42− id: d

50+ id: d

43− property bool bindGuard: false

51+ property bool bindGuard: false

44− property var application: null

52+ property var application: null

45− Component.onCompleted: {

53+ Component.onCompleted: {

46− application = ApplicationManager.findApplication(root.appId);

54+ application = ApplicationManager.findApplication(root.appId);

55+ }

47 }

56 }

48− }

50− Connections {

58+ Connections {

51− target: ApplicationManager

59+ target: ApplicationManager

52− onCountChanged: {

60+ onCountChanged: {

53− d.application = ApplicationManager.findApplication(root.appId);

61+ d.application = ApplicationManager.findApplication(root.appId);

62+ }

54 }

63 }

55− }

57− Layout.fillWidth: true

65+ Layout.fillWidth: true

58− CheckBox {

66+ CheckBox {

59− id: checkbox

67+ id: checkbox

60− checked: false

68+ checked: false

61− activeFocusOnPress: false

69+ activeFocusOnPress: false

63− onTriggered: {

71+ onTriggered: {

64− if (d.bindGuard) { return; }

72+ if (d.bindGuard) { return; }

65− d.bindGuard = true;

73+ d.bindGuard = true;

67− if (checked) {

75+ if (checked) {

68− ApplicationManager.startApplication(root.appId);

76+ ApplicationManager.startApplication(root.appId);

69− } else {

77+ } else {

70− ApplicationManager.stopApplication(root.appId);

78+ ApplicationManager.stopApplication(root.appId);

79+ }

80+ d.bindGuard = false;

71 }

81 }

72− d.bindGuard = false;

73− }

74− onCheckedChanged: {

82+ onCheckedChanged: {

75− if (d.bindGuard) { return; }

83+ if (d.bindGuard) { return; }

76− d.bindGuard = true;

84+ d.bindGuard = true;

78− root.checked = checked;

86+ root.checked = checked;

80− d.bindGuard = false;

88+ d.bindGuard = false;

89+ }

90+ Binding {

91+ target: checkbox

92+ property: "checked"

93+ value: d.application != null

94+ }

81 }

95 }

82− Binding {

96+ Label {

83− target: checkbox

97+ id: appIdLabel

84− property: "checked"

98+ text: root.appId

85− value: d.application != null

99+ color: "white"

100+ anchors.verticalCenter: parent.verticalCenter

86 }

101 }

87− }

88− Label {

89− id: appIdLabel

90− text: root.appId

91− color: "white"

92− anchors.verticalCenter: parent.verticalCenter

93− }

94− Rectangle {

102+ Rectangle {

95− color: {

103+ color: {

96− if (d.application) {

104+ if (d.application) {

97− if (d.application.state === ApplicationInfoInterface.Starting) {

105+ if (d.application.state === ApplicationInfoInterface.Starting) {

98− return "yellow";

106+ return "yellow";

99− } else if (d.application.state === ApplicationInfoInterface.Running) {

107+ } else if (d.application.state === ApplicationInfoInterface.Running) {

100− return "green";

108+ return "green";

101− } else if (d.application.state === ApplicationInfoInterface.Suspended) {

109+ } else if (d.application.state === ApplicationInfoInterface.Suspended) {

102− return "blue";

110+ return "blue";

111+ } else {

112+ return "darkred";

113+ }

103 } else {

114 } else {

104 return "darkred";

115 return "darkred";

105 }

116 }

106− } else {

117+ }

107− return "darkred";

118+ width: height

119+ height: appIdLabel.height * 0.7

120+ anchors.verticalCenter: parent.verticalCenter

121+ }

122+

123+ MouseArea {

124+ width: height

125+ height: appIdLabel.height * 0.7

126+ anchors.verticalCenter: parent.verticalCenter

127+ onClicked: root.createSurface()

128+ enabled: d.application && d.application.state === ApplicationInfoInterface.Running

129+ visible: enabled

130+ Label {

131+ text: "➕"

132+ color: "white"

133+ anchors.centerIn: parent

134+ }

135+ }

136+ }

137+ Repeater {

138+ model: d.application ? d.application.surfaceList : null

139+ RowLayout {

140+ spacing: units.gu(1)

141+ Label {

142+ color: "white"

143+ text: "- " + model.surface.name

144+ }

145+ MouseArea {

146+ width: height

147+ height: appIdLabel.height * 0.7

148+ anchors.verticalCenter: parent.verticalCenter

149+ enabled: model.surface.live

150+ visible: enabled

151+ onClicked: model.surface.setLive(false);

152+ Label {

153+ text: "⛒"

154+ color: "white"

155+ anchors.centerIn: parent

156+ }

108 }

157 }

109 }

158 }

110− width: height

111− height: appIdLabel.height * 0.7

112− anchors.verticalCenter: parent.verticalCenter

113 }

159 }

114}

160}

tests/qmltests/Stages/RecursingChildSessionControl.qml+10−61

@@ -1,5 +1,5 @@

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

@@ -22,16 +22,7 @@ import Unity.Application 0.1

22ColumnLayout {

23 id: root

25− property var session

25+ property var surface

26− property var childSessions: session ? session.childSessions : 0

27− property bool removable: false

28− property alias surfaceCheckbox: _surfaceCheckbox

29−

30− property var screenshotIds: [ "gallery", "map", "facebook", "camera", "browser", "music", "twitter"]

31−

32− onSessionChanged: {

33− if (!session) surfaceCheckbox.checked = false;

34− }

36 Column {

27 Column {

37 id: column

28 id: column

@@ -41,7 +32,7 @@ ColumnLayout {

42 Repeater {

33 Repeater {

43 id: repeater

34 id: repeater

44− model: root.childSessions

35+ model: root.surface ? root.surface.promptSurfaceList : null

45 delegate: Rectangle {

36 delegate: Rectangle {

46 border {

37 border {

47 color: "black"

38 color: "black"

@@ -71,8 +62,7 @@ ColumnLayout {

71 }

62 }

73 onLoaded: {

64 onLoaded: {

74− item.session = modelData;

65+ item.surface = model.surface;

75− item.removable = true;

76 }

66 }

77 }

67 }

78 }

68 }

@@ -83,62 +73,21 @@ ColumnLayout {

83 Layout.fillWidth: true

73 Layout.fillWidth: true

84 spacing: units.gu(1)

74 spacing: units.gu(1)

86− RowLayout {

87− Layout.fillWidth: true

88−

89− CheckBox {

90− id: _surfaceCheckbox;

91− checked: root.session.lastSurface ? true : false

92− activeFocusOnPress: false

93− enabled: root.session

94− onCheckedChanged: {

95− if (checked) {

96− root.session.createSurface();

97− } else if (root.session && root.session.lastSurface) {

98− ApplicationTest.removeSurface(root.session.lastSurface);

99− }

100− }

101−

102− Connections {

103− target: root.session ? root.session : null

104− onLastSurfaceChanged: {

105− surfaceCheckbox.checked = root.session.lastSurface !== null

106− }

107− }

108− }

109−

110− Label {

111− text: "Surface"

112− anchors.verticalCenter: parent.verticalCenter

113− }

114− }

115−

116 RowLayout {

76 RowLayout {

117 id: buttonLayout

77 id: buttonLayout

118

119 Button {

79 Button {

120− enabled: root.session

80+ enabled: root.surface

121 activeFocusOnPress: false

81 activeFocusOnPress: false

122− text: removable ? "Remove" : "Release"

82+ text: "Remove"

123− onClicked: {

83+ onClicked: { root.surface.close(); }

124− if (removable) {

125− // release the surface first. simulates mir app closing

126− if (root.session.lastSurface) ApplicationTest.removeSurface(root.session.lastSurface);

127− ApplicationTest.removeSession(root.session);

128− } else {

129− root.session.release();

130− }

131− }

132 }

84 }

133

134 Button {

86 Button {

135− enabled: root.session !== null

87+ enabled: root.surface !== null

136 activeFocusOnPress: false

88 activeFocusOnPress: false

137− text: "Add Child"

89+ text: "Add Prompt Surface"

138− onClicked: {

90+ onClicked: { root.surface.createPromptSurface(); }

139− var screenshot = Math.round(Math.random()*100 % (screenshotIds.length-1));

140− var session = ApplicationTest.addChildSession(root.session, root.screenshotIds[screenshot], true);

141− }

142 }

91 }

143 }

92 }

144 }

93 }

tests/qmltests/Stages/tst_ApplicationWindow.qml+73−59

@@ -1,5 +1,5 @@

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

@@ -34,16 +34,9 @@ Rectangle {

34 root.fakeApplication = ApplicationManager.add("gallery-app");

35 root.fakeApplication.manualSurfaceCreation = true;

36 root.fakeApplication.setState(ApplicationInfoInterface.Starting);

37+ applicationWindowLoader.item.application = root.fakeApplication;

37 }

38 }

38 property QtObject fakeApplication: null

39 property QtObject fakeApplication: null

39− readonly property var fakeSession: fakeApplication ? fakeApplication.session : null

40−

41− Connections {

42− target: fakeApplication

43− onSessionChanged: {

44− sessionCheckbox.checked = fakeApplication.session !== null

45− }

46− }

48 Loader {

41 Loader {

49 id: applicationWindowLoader

42 id: applicationWindowLoader

@@ -58,7 +51,6 @@ Rectangle {

58 sourceComponent: Component {

51 sourceComponent: Component {

59 ApplicationWindow {

52 ApplicationWindow {

60 anchors.fill: parent

53 anchors.fill: parent

61− application: fakeApplication

62 surfaceOrientationAngle: 0

54 surfaceOrientationAngle: 0

63 interactive: true

55 interactive: true

64 focus: true

56 focus: true

@@ -86,18 +78,27 @@ Rectangle {

86 Layout.fillWidth: true

78 Layout.fillWidth: true

88 CheckBox {

80 CheckBox {

81+ id: surfaceCheckbox;

89− id: sessionCheckbox; checked: false

82+ checked: false;

90 activeFocusOnPress: false

83 activeFocusOnPress: false

91 onCheckedChanged: {

84 onCheckedChanged: {

92− if (checked && !fakeApplication.session) {

85+ if (applicationWindowLoader.status !== Loader.Ready)

93− fakeApplication.createSession();

86+ return;

94− } else if (!checked && fakeApplication.session) {

87+

95− fakeApplication.destroySession();

88+ if (checked) {

89+ applicationWindowLoader.item.surface = SurfaceManager.createSurface("foo",

90+ Mir.NormalType, Mir.MaximizedState, root.fakeApplication);

91+

92+ root.fakeApplication.setState(ApplicationInfoInterface.Running);

93+ } else {

94+ if (applicationWindowLoader.item.surface) {

95+ applicationWindowLoader.item.surface.setLive(false);

96+ }

96 }

97 }

98 }

99 }

99 Label {

100 Label {

100− text: "Session"

101+ text: "Surface"

101 anchors.verticalCenter: parent.verticalCenter

102 anchors.verticalCenter: parent.verticalCenter

102 }

103 }

104 }

@@ -117,7 +118,7 @@ Rectangle {

117 id: sessionControl

118 id: sessionControl

118 anchors { left: parent.left; right: parent.right; }

119 anchors { left: parent.left; right: parent.right; }

119

120

120− session: fakeSession

121+ surface: applicationWindowLoader.item ? applicationWindowLoader.item.surface : null

121 }

122 }

123 }

123

124

@@ -143,7 +144,15 @@ Rectangle {

143 }

144 }

144 onSelectedApplicationStateChanged: {

145 onSelectedApplicationStateChanged: {

145 // state is a read-only property, thus we have to call the setter function

146 // state is a read-only property, thus we have to call the setter function

147+ if (fakeApplication && fakeApplication.state != selectedApplicationState) {

146− fakeApplication.setState(selectedApplicationState);

148+ fakeApplication.setState(selectedApplicationState);

149+ }

150+ }

151+ Connections {

152+ target: fakeApplication

153+ onStateChanged: {

154+ testCase.setApplicationState(state);

155+ }

147 }

156 }

148 }

157 }

149

158

@@ -197,6 +206,8 @@ Rectangle {

197 }

206 }

198 }

207 }

199

208

209+ property var applicationWindow: applicationWindowLoader.item

210+

200 // holds some of the internal ApplicationWindow objects we probe during the tests

211 // holds some of the internal ApplicationWindow objects we probe during the tests

201 property var stateGroup: null

212 property var stateGroup: null

202

213

@@ -213,11 +224,6 @@ Rectangle {

213 findInterestingApplicationWindowChildren();

224 findInterestingApplicationWindowChildren();

214 }

225 }

215

226

216− function initSession() {

217− sessionCheckbox.checked = true;

218− sessionControl.surfaceCheckbox.checked = true;

219− }

220−

221 function cleanup() {

227 function cleanup() {

222 forgetApplicationWindowChildren();

228 forgetApplicationWindowChildren();

223

229

@@ -238,10 +244,17 @@ Rectangle {

238 // deleted, so you end up with two instances in memory.

244 // deleted, so you end up with two instances in memory.

239 tryCompare(applicationWindowLoader, "itemDestroyed", true);

245 tryCompare(applicationWindowLoader, "itemDestroyed", true);

240

246

241− appStateSelector.selectedIndex = 0;

247+ setApplicationState(appStarting);

242− sessionCheckbox.checked = false;

248+ surfaceCheckbox.checked = false;

249+

250+ ApplicationManager.stopApplication("gallery-app");

251+ root.fakeApplication = ApplicationManager.add("gallery-app");

252+ root.fakeApplication.manualSurfaceCreation = true;

253+ root.fakeApplication.setState(ApplicationInfoInterface.Starting);

243

254

244 applicationWindowLoader.active = true;

255 applicationWindowLoader.active = true;

256+

257+ applicationWindowLoader.item.application = root.fakeApplication;

245 }

258 }

246

259

247 function test_showSplashUntilAppFullyInit_data() {

260 function test_showSplashUntilAppFullyInit_data() {

@@ -256,7 +269,7 @@ Rectangle {

256 verify(stateGroup.state === "splashScreen");

269 verify(stateGroup.state === "splashScreen");

257

270

258 if (data.swapInitOrder) {

271 if (data.swapInitOrder) {

259− initSession();

272+ surfaceCheckbox.checked = true;

260 } else {

273 } else {

261 setApplicationState(appRunning);

274 setApplicationState(appRunning);

262 }

275 }

@@ -266,14 +279,14 @@ Rectangle {

266 if (data.swapInitOrder) {

279 if (data.swapInitOrder) {

267 setApplicationState(appRunning);

280 setApplicationState(appRunning);

268 } else {

281 } else {

269− initSession();

282+ surfaceCheckbox.checked = true;

270 }

283 }

271

284

272 tryCompare(stateGroup, "state", "surface");

285 tryCompare(stateGroup, "state", "surface");

273 }

286 }

274

287

275 function test_suspendedAppShowsSurface() {

288 function test_suspendedAppShowsSurface() {

276− initSession();

289+ surfaceCheckbox.checked = true;

277 setApplicationState(appRunning);

290 setApplicationState(appRunning);

278

291

279 tryCompare(stateGroup, "state", "surface");

292 tryCompare(stateGroup, "state", "surface");

@@ -287,7 +300,7 @@ Rectangle {

287 }

300 }

288

301

289 function test_killedAppShowsScreenshot() {

302 function test_killedAppShowsScreenshot() {

290− initSession();

303+ surfaceCheckbox.checked = true;

291 setApplicationState(appRunning);

304 setApplicationState(appRunning);

292 tryCompare(stateGroup, "state", "surface");

305 tryCompare(stateGroup, "state", "surface");

293

306

@@ -297,16 +310,17 @@ Rectangle {

297 verify(fakeApplication.surface !== null);

310 verify(fakeApplication.surface !== null);

298

311

299 // kill it!

312 // kill it!

313+ surfaceCheckbox.checked = false;

300 setApplicationState(appStopped);

314 setApplicationState(appStopped);

301

315

302 tryCompare(stateGroup, "state", "screenshot");

316 tryCompare(stateGroup, "state", "screenshot");

303− tryCompare(fakeApplication, "session", null);

317+ tryCompare(fakeApplication.surfaceList, "count", 0);

304 }

318 }

305

319

306 function test_restartApp() {

320 function test_restartApp() {

307− var screenshotImage = findChild(applicationWindowLoader.item, "screenshotImage");

321+ var screenshotImage = findChild(applicationWindow, "screenshotImage");

308

322

309− initSession();

323+ surfaceCheckbox.checked = true;

310 setApplicationState(appRunning);

324 setApplicationState(appRunning);

311 tryCompare(stateGroup, "state", "surface");

325 tryCompare(stateGroup, "state", "surface");

312 waitUntilTransitionsEnd(stateGroup);

326 waitUntilTransitionsEnd(stateGroup);

@@ -314,109 +328,109 @@ Rectangle {

314 setApplicationState(appSuspended);

328 setApplicationState(appSuspended);

315

329

316 // kill it

330 // kill it

331+ surfaceCheckbox.checked = false;

317 setApplicationState(appStopped);

332 setApplicationState(appStopped);

318

333

319 tryCompare(stateGroup, "state", "screenshot");

334 tryCompare(stateGroup, "state", "screenshot");

320 waitUntilTransitionsEnd(stateGroup);

335 waitUntilTransitionsEnd(stateGroup);

321− tryCompare(fakeApplication, "session", null);

336+ tryCompare(applicationWindow, "surface", null);

322

337

323 // and restart it

338 // and restart it

324 setApplicationState(appStarting);

339 setApplicationState(appStarting);

325

340

326 waitUntilTransitionsEnd(stateGroup);

341 waitUntilTransitionsEnd(stateGroup);

327 verify(stateGroup.state === "screenshot");

342 verify(stateGroup.state === "screenshot");

328− verify(fakeSession === null);

343+ verify(applicationWindow.surface === null);

329

344

330 setApplicationState(appRunning);

345 setApplicationState(appRunning);

331

346

332 waitUntilTransitionsEnd(stateGroup);

347 waitUntilTransitionsEnd(stateGroup);

333 verify(stateGroup.state === "screenshot");

348 verify(stateGroup.state === "screenshot");

334

349

335− initSession();

350+ surfaceCheckbox.checked = true;

336

351

337 tryCompare(stateGroup, "state", "surface");

352 tryCompare(stateGroup, "state", "surface");

338 tryCompare(screenshotImage, "status", Image.Null);

353 tryCompare(screenshotImage, "status", Image.Null);

339 }

354 }

340

355

341 function test_appCrashed() {

356 function test_appCrashed() {

342− initSession();

357+ surfaceCheckbox.checked = true;

343 setApplicationState(appRunning);

358 setApplicationState(appRunning);

344 tryCompare(stateGroup, "state", "surface");

359 tryCompare(stateGroup, "state", "surface");

345 waitUntilTransitionsEnd(stateGroup);

360 waitUntilTransitionsEnd(stateGroup);

346

361

347 // oh, it crashed...

362 // oh, it crashed...

363+ surfaceCheckbox.checked = false;

348 setApplicationState(appStopped);

364 setApplicationState(appStopped);

349

365

350 tryCompare(stateGroup, "state", "screenshot");

366 tryCompare(stateGroup, "state", "screenshot");

351− tryCompare(fakeApplication, "session", null);

367+ tryCompare(applicationWindow, "surface", null);

352 }

368 }

353

369

354 function test_keepSurfaceWhileInvisible() {

370 function test_keepSurfaceWhileInvisible() {

355− initSession();

371+ surfaceCheckbox.checked = true;

356 setApplicationState(appRunning);

372 setApplicationState(appRunning);

357 tryCompare(stateGroup, "state", "surface");

373 tryCompare(stateGroup, "state", "surface");

358 waitUntilTransitionsEnd(stateGroup);

374 waitUntilTransitionsEnd(stateGroup);

359− verify(fakeSession.lastSurface !== null);

375+ verify(applicationWindow.surface !== null);

360

376

361− applicationWindowLoader.item.visible = false;

377+ applicationWindow.visible = false;

362

378

363 waitUntilTransitionsEnd(stateGroup);

379 waitUntilTransitionsEnd(stateGroup);

364 verify(stateGroup.state === "surface");

380 verify(stateGroup.state === "surface");

365− verify(fakeSession.lastSurface !== null);

381+ verify(applicationWindow.surface !== null);

366

382

367− applicationWindowLoader.item.visible = true;

383+ applicationWindow.visible = true;

368

384

369 waitUntilTransitionsEnd(stateGroup);

385 waitUntilTransitionsEnd(stateGroup);

370 verify(stateGroup.state === "surface");

386 verify(stateGroup.state === "surface");

371− verify(fakeSession.lastSurface !== null);

387+ verify(applicationWindow.surface !== null);

372 }

388 }

373

389

374 function test_touchesReachSurfaceWhenItsShown() {

390 function test_touchesReachSurfaceWhenItsShown() {

375 setApplicationState(appRunning);

391 setApplicationState(appRunning);

376− initSession();

392+ surfaceCheckbox.checked = true;

377

393

378 tryCompare(stateGroup, "state", "surface");

394 tryCompare(stateGroup, "state", "surface");

379

395

380 waitUntilTransitionsEnd(stateGroup);

396 waitUntilTransitionsEnd(stateGroup);

381

397

382− var surfaceItem = findChild(applicationWindowLoader.item, "surfaceItem");

398+ var surfaceItem = findChild(applicationWindow, "surfaceItem");

383 verify(surfaceItem);

399 verify(surfaceItem);

384− verify(surfaceItem.surface === fakeSession.lastSurface);

400+ verify(surfaceItem.surface === applicationWindow.surface);

385

401

386 surfaceItem.touchPressCount = 0;

402 surfaceItem.touchPressCount = 0;

387 surfaceItem.touchReleaseCount = 0;

403 surfaceItem.touchReleaseCount = 0;

388

404

389− tap(applicationWindowLoader.item,

405+ tap(applicationWindow);

390− applicationWindowLoader.item.width / 2, applicationWindowLoader.item.height / 2);

391

406

392 verify(surfaceItem.touchPressCount === 1);

407 verify(surfaceItem.touchPressCount === 1);

393 verify(surfaceItem.touchReleaseCount === 1);

408 verify(surfaceItem.touchReleaseCount === 1);

394 }

409 }

395

410

396 function test_showNothingOnSuddenSurfaceLoss() {

411 function test_showNothingOnSuddenSurfaceLoss() {

397− initSession();

412+ surfaceCheckbox.checked = true;

398 setApplicationState(appRunning);

413 setApplicationState(appRunning);

399 tryCompare(stateGroup, "state", "surface");

414 tryCompare(stateGroup, "state", "surface");

400 waitUntilTransitionsEnd(stateGroup);

415 waitUntilTransitionsEnd(stateGroup);

401

416

402− sessionControl.surfaceCheckbox.checked = false;

417+ applicationWindow.surface = null;

403

418

404 tryCompare(stateGroup, "state", "void");

419 tryCompare(stateGroup, "state", "void");

405 }

420 }

406

421

407 function test_surfaceActiveFocusFollowsAppWindowInterative() {

422 function test_surfaceActiveFocusFollowsAppWindowInterative() {

408− fakeApplication.createSession();

409− applicationWindowLoader.item.interactive = false;

423+ applicationWindow.interactive = false;

410− applicationWindowLoader.item.interactive = true;

424+ applicationWindow.interactive = true;

411− fakeSession.createSurface();

425+ surfaceCheckbox.checked = true;

412

426

413− compare(fakeSession.lastSurface.activeFocus, true);

427+ compare(applicationWindow.surface.activeFocus, true);

414

428

415− applicationWindowLoader.item.interactive = false;

429+ applicationWindow.interactive = false;

416− compare(fakeSession.lastSurface.activeFocus, false);

430+ compare(applicationWindow.surface.activeFocus, false);

417

431

418− applicationWindowLoader.item.interactive = true;

432+ applicationWindow.interactive = true;

419− compare(fakeSession.lastSurface.activeFocus, true);

433+ compare(applicationWindow.surface.activeFocus, true);

420 }

434 }

421 }

435 }

422}

436}

tests/qmltests/Stages/tst_DesktopStage.qml+228−159

@@ -1,5 +1,5 @@

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

@@ -53,6 +53,11 @@ Item {

53 }

54 }

56+ TopLevelSurfaceList {

57+ id: topSurfaceList

58+ applicationsModel: ApplicationManager

59+ }

60+

56 Loader {

61 Loader {

57 id: desktopStageLoader

62 id: desktopStageLoader

58 x: ((root.width - controls.width) - width) / 2

63 x: ((root.width - controls.width) - width) / 2

@@ -68,6 +73,7 @@ Item {

68 color: "white"

73 color: "white"

69 anchors.fill: parent

74 anchors.fill: parent

70 background: "../../../qml/graphics/tablet_background.jpg"

75 background: "../../../qml/graphics/tablet_background.jpg"

76+ focus: true

72 Component.onCompleted: {

78 Component.onCompleted: {

73 edgeBarrierControls.target = testCase.findChild(this, "edgeBarrierController");

79 edgeBarrierControls.target = testCase.findChild(this, "edgeBarrierController");

@@ -76,6 +82,8 @@ Item {

76 desktopStageLoader.itemDestroyed = true;

82 desktopStageLoader.itemDestroyed = true;

77 }

83 }

78 orientations: Orientations {}

84 orientations: Orientations {}

85+ applicationManager: ApplicationManager

86+ topLevelSurfaceList: topSurfaceList

79 }

87 }

80 }

88 }

81 }

89 }

@@ -103,7 +111,7 @@ Item {

103 activeFocusOnPress: false

111 activeFocusOnPress: false

104 onClicked: {

112 onClicked: {

105 if (ApplicationManager.focusedApplicationId) {

113 if (ApplicationManager.focusedApplicationId) {

106− var surface = ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).session.lastSurface;

114+ var surface = ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).surfaceList.get(0);

107 surface.slowToResize = true;

115 surface.slowToResize = true;

108 }

116 }

109 }

117 }

@@ -137,6 +145,19 @@ Item {

137

145

138 property Item desktopStage: desktopStageLoader.status === Loader.Ready ? desktopStageLoader.item : null

146 property Item desktopStage: desktopStageLoader.status === Loader.Ready ? desktopStageLoader.item : null

139

147

148+ function init() {

149+ // wait until unity8-dash is up and running.

150+ // it's started automatically by ApplicationManager mock implementation

151+ tryCompare(ApplicationManager, "count", 1);

152+ var dashApp = ApplicationManager.findApplication("unity8-dash");

153+ verify(dashApp);

154+ tryCompare(dashApp, "state", ApplicationInfoInterface.Running);

155+

156+ tryCompare(topSurfaceList, "count", 1);

157+ tryCompareFunction(function(){return topSurfaceList.surfaceAt(0) != null;}, true);

158+ compare(MirFocusController.focusedSurface, topSurfaceList.surfaceAt(0));

159+ }

160+

140 function cleanup() {

161 function cleanup() {

141 desktopStageLoader.itemDestroyed = false;

162 desktopStageLoader.itemDestroyed = false;

142 desktopStageLoader.active = false;

163 desktopStageLoader.active = false;

@@ -149,43 +170,71 @@ Item {

149 // Shell instance gets destroyed.

170 // Shell instance gets destroyed.

150 tryCompare(desktopStageLoader, "itemDestroyed", true);

171 tryCompare(desktopStageLoader, "itemDestroyed", true);

151

172

152− killAllRunningApps();

173+ killApps();

174+

175+ root.resetGeometry();

153

176

154 desktopStageLoader.active = true;

177 desktopStageLoader.active = true;

155 tryCompare(desktopStageLoader, "status", Loader.Ready);

178 tryCompare(desktopStageLoader, "status", Loader.Ready);

156− root.resetGeometry();

157− }

158

179

159− function killAllRunningApps() {

160− while (ApplicationManager.count > 0) {

161− ApplicationManager.stopApplication(ApplicationManager.get(0).appId);

162− }

163− compare(ApplicationManager.count, 0)

164 }

180 }

165

181

166− function waitUntilAppSurfaceShowsUp(appId) {

182+ function waitUntilAppSurfaceShowsUp(surfaceId) {

167− var appWindow = findChild(desktopStage, "appWindow_" + appId);

183+ var appDelegate = findChild(desktopStage, "appDelegate_" + surfaceId);

184+ verify(appDelegate);

185+ var appWindow = findChild(appDelegate, "appWindow");

168 verify(appWindow);

186 verify(appWindow);

169 var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

187 var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

170 verify(appWindowStates);

188 verify(appWindowStates);

171 tryCompare(appWindowStates, "state", "surface");

189 tryCompare(appWindowStates, "state", "surface");

172 }

190 }

173

191

192+ /*

193+ Returns the appDelegate of the first surface created by the app with the specified appId

194+ */

174 function startApplication(appId) {

195 function startApplication(appId) {

196+ try {

175− var app = ApplicationManager.findApplication(appId);

197+ var app = ApplicationManager.findApplication(appId);

176− if (!app) {

198+ if (app) {

199+ for (var i = 0; i < topSurfaceList.count; i++) {

200+ if (topSurfaceList.applicationAt(i).appId === appId) {

201+ var appRepeater = findChild(desktopStage, "appRepeater");

202+ verify(appRepeater);

203+ return appRepeater.itemAt(i);

204+ }

205+ }

206+ }

207+

208+ var surfaceId = topSurfaceList.nextId;

177 app = ApplicationManager.startApplication(appId);

209 app = ApplicationManager.startApplication(appId);

210+ verify(app);

211+ waitUntilAppSurfaceShowsUp(surfaceId);

212+ compare(app.surfaceList.count, 1);

213+

214+ return findChild(desktopStage, "appDelegate_" + surfaceId);

215+ } catch(err) {

216+ throw new Error("startApplication("+appId+") called from line " + util.callerLine(1) + " failed!");

217+ }

218+ }

219+

220+ function maximizeAppDelegate(appDelegate) {

221+ var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

222+ if (!maximizeButton) {

223+ fail("Could not find maximizeWindowButton of appDelegate=" + appDelegate);

224+ }

225+ mouseClick(maximizeButton);

226+

227+ try {

228+ tryCompare(appDelegate, "visuallyMaximized", true);

229+ } catch(err) {

230+ fail("appDelegate.visuallyMaximized !== true");

178 }

231 }

179− verify(app);

180− waitUntilAppSurfaceShowsUp(appId);

181− verify(app.session.lastSurface);

182− return app;

183 }

232 }

184

233

185 function test_appFocusSwitch_data() {

234 function test_appFocusSwitch_data() {

186 return [

235 return [

187− {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 0, focusTo: 1 },

236+ {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "gmail-webapp" ], focusfrom: 0, focusTo: 1 },

188− {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 1, focusTo: 0 },

237+ {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "gmail-webapp" ], focusfrom: 1, focusTo: 0 },

189 ]

238 ]

190 }

239 }

191

240

@@ -193,10 +242,10 @@ Item {

193 data.apps.forEach(startApplication);

242 data.apps.forEach(startApplication);

194

243

195 ApplicationManager.requestFocusApplication(data.apps[data.focusfrom]);

244 ApplicationManager.requestFocusApplication(data.apps[data.focusfrom]);

196− tryCompare(ApplicationManager.findApplication(data.apps[data.focusfrom]).session.lastSurface, "activeFocus", true);

245+ tryCompare(ApplicationManager.findApplication(data.apps[data.focusfrom]).surfaceList.get(0), "activeFocus", true);

197

246

198 ApplicationManager.requestFocusApplication(data.apps[data.focusTo]);

247 ApplicationManager.requestFocusApplication(data.apps[data.focusTo]);

199− tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).session.lastSurface, "activeFocus", true);

248+ tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).surfaceList.get(0), "activeFocus", true);

200 }

249 }

201

250

202 function test_tappingOnWindowChangesFocusedApp_data() {

251 function test_tappingOnWindowChangesFocusedApp_data() {

@@ -207,21 +256,24 @@ Item {

207 }

256 }

208

257

209 function test_tappingOnWindowChangesFocusedApp(data) {

258 function test_tappingOnWindowChangesFocusedApp(data) {

259+ var appDelegates = [];

260+ for (var i = 0; i < data.apps.length; i++) {

210− data.apps.forEach(startApplication);

261+ appDelegates[i] = startApplication(data.apps[i]);

262+ }

211− var fromAppId = data.apps[data.focusfrom];

263+ var fromDelegate = appDelegates[data.focusfrom];

212− var toAppId = data.apps[data.focusTo]

264+ var toDelegate = appDelegates[data.focusTo];

213

265

214− var fromAppWindow = findChild(desktopStage, "appWindow_" + fromAppId);

266+ var fromAppWindow = findChild(fromDelegate, "appWindow");

215 verify(fromAppWindow);

267 verify(fromAppWindow);

216 tap(fromAppWindow);

268 tap(fromAppWindow);

217− compare(fromAppWindow.application.session.lastSurface.activeFocus, true);

269+ compare(fromDelegate.surface.activeFocus, true);

218− compare(ApplicationManager.focusedApplicationId, fromAppId);

270+ compare(MirFocusController.focusedSurface, fromDelegate.surface);

219

271

220− var toAppWindow = findChild(desktopStage, "appWindow_" + toAppId);

272+ var toAppWindow = findChild(toDelegate, "appWindow");

221 verify(toAppWindow);

273 verify(toAppWindow);

222 tap(toAppWindow);

274 tap(toAppWindow);

223− compare(toAppWindow.application.session.lastSurface.activeFocus, true);

275+ compare(toDelegate.surface.activeFocus, true);

224− compare(ApplicationManager.focusedApplicationId, toAppId);

276+ compare(MirFocusController.focusedSurface, toDelegate.surface);

225 }

277 }

226

278

227 function test_clickingOnWindowChangesFocusedApp_data() {

279 function test_clickingOnWindowChangesFocusedApp_data() {

@@ -229,21 +281,24 @@ Item {

229 }

281 }

230

282

231 function test_clickingOnWindowChangesFocusedApp(data) {

283 function test_clickingOnWindowChangesFocusedApp(data) {

284+ var appDelegates = [];

285+ for (var i = 0; i < data.apps.length; i++) {

232− data.apps.forEach(startApplication);

286+ appDelegates[i] = startApplication(data.apps[i]);

287+ }

233− var fromAppId = data.apps[data.focusfrom];

288+ var fromDelegate = appDelegates[data.focusfrom];

234− var toAppId = data.apps[data.focusTo]

289+ var toDelegate = appDelegates[data.focusTo];

235

290

236− var fromAppWindow = findChild(desktopStage, "appWindow_" + fromAppId);

291+ var fromAppWindow = findChild(fromDelegate, "appWindow");

237 verify(fromAppWindow);

292 verify(fromAppWindow);

238 mouseClick(fromAppWindow);

293 mouseClick(fromAppWindow);

239− compare(fromAppWindow.application.session.lastSurface.activeFocus, true);

294+ compare(fromDelegate.surface.activeFocus, true);

240− compare(ApplicationManager.focusedApplicationId, fromAppId);

295+ compare(MirFocusController.focusedSurface, fromDelegate.surface);

241

296

242− var toAppWindow = findChild(desktopStage, "appWindow_" + toAppId);

297+ var toAppWindow = findChild(toDelegate, "appWindow");

243 verify(toAppWindow);

298 verify(toAppWindow);

244 mouseClick(toAppWindow);

299 mouseClick(toAppWindow);

245− compare(toAppWindow.application.session.lastSurface.activeFocus, true);

300+ compare(toDelegate.surface.activeFocus, true);

246− compare(ApplicationManager.focusedApplicationId, toAppId);

301+ compare(MirFocusController.focusedSurface, toDelegate.surface);

247 }

302 }

248

303

249 function test_tappingOnDecorationFocusesApplication_data() {

304 function test_tappingOnDecorationFocusesApplication_data() {

@@ -253,24 +308,49 @@ Item {

253 ]

308 ]

254 }

309 }

255

310

311+ function findDecoratedWindow(surfaceId) {

312+ var appDelegate = findChild(desktopStage, "appDelegate_" + surfaceId);

313+ if (!appDelegate) {

314+ console.warn("Could not find appDelegate for surfaceId="+surfaceId);

315+ return null;

316+ }

317+ return findChild(appDelegate, "decoratedWindow");

318+ }

319+

320+ function findWindowDecoration(surfaceId) {

321+ var appDelegate = findChild(desktopStage, "appDelegate_" + surfaceId);

322+ if (!appDelegate) {

323+ console.warn("Could not find appDelegate for surfaceId="+surfaceId);

324+ return null;

325+ }

326+ return findChild(appDelegate, "appWindowDecoration");

327+ }

328+

256 function test_tappingOnDecorationFocusesApplication(data) {

329 function test_tappingOnDecorationFocusesApplication(data) {

330+ var appDelegates = [];

331+ for (var i = 0; i < data.apps.length; i++) {

257− data.apps.forEach(startApplication);

332+ appDelegates[i] = startApplication(data.apps[i]);

333+ }

334+

335+ var fromDelegate = appDelegates[data.focusfrom];

336+ var toDelegate = appDelegates[data.focusTo];

258

337

259− var fromAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusfrom]);

338+ var fromAppDecoration = findChild(fromDelegate, "appWindowDecoration");

260 verify(fromAppDecoration);

339 verify(fromAppDecoration);

261 tap(fromAppDecoration);

340 tap(fromAppDecoration);

262

341

263− var fromApp = ApplicationManager.findApplication(data.apps[data.focusfrom]);

264− verify(fromApp);

265− tryCompare(fromApp.session.lastSurface, "activeFocus", true);

342+ tryCompare(fromDelegate.surface, "activeFocus", true);

266

343

267− var toAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusTo]);

344+ var toAppDecoration = findChild(toDelegate, "appWindowDecoration");

268 verify(toAppDecoration);

345 verify(toAppDecoration);

346+

347+ // FIXME: Wait a bit before the second tap or the window decoration will say it got double clicked.

348+ // No idea why.

349+ wait(700);

350+

269 tap(toAppDecoration);

351 tap(toAppDecoration);

270

352

271− var toApp = ApplicationManager.findApplication(data.apps[data.focusTo]);

272− verify(toApp);

273− tryCompare(toApp.session.lastSurface, "activeFocus", true);

353+ tryCompare(toDelegate.surface, "activeFocus", true);

274 }

354 }

275

355

276 function test_clickingOnDecorationFocusesApplication_data() {

356 function test_clickingOnDecorationFocusesApplication_data() {

@@ -278,159 +358,158 @@ Item {

278 }

358 }

279

359

280 function test_clickingOnDecorationFocusesApplication(data) {

360 function test_clickingOnDecorationFocusesApplication(data) {

361+ var appDelegates = [];

362+ for (var i = 0; i < data.apps.length; i++) {

281− data.apps.forEach(startApplication);

363+ appDelegates[i] = startApplication(data.apps[i]);

364+ }

365+ var fromDelegate = appDelegates[data.focusfrom];

366+ var toDelegate = appDelegates[data.focusTo];

282

367

283− var fromAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusfrom]);

368+ var fromAppDecoration = findChild(fromDelegate, "appWindowDecoration");

284 verify(fromAppDecoration);

369 verify(fromAppDecoration);

285 mouseClick(fromAppDecoration);

370 mouseClick(fromAppDecoration);

286− tryCompare(ApplicationManager.findApplication(data.apps[data.focusfrom]).session.lastSurface, "activeFocus", true);

371+ tryCompare(fromDelegate.surface, "activeFocus", true);

287

372

288− var toAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusTo]);

373+ var toAppDecoration = findChild(toDelegate, "appWindowDecoration");

289 verify(toAppDecoration);

374 verify(toAppDecoration);

290 mouseClick(toAppDecoration);

375 mouseClick(toAppDecoration);

291− tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).session.lastSurface, "activeFocus", true);

376+ tryCompare(toDelegate.surface, "activeFocus", true);

292 }

377 }

293

378

294 function test_windowMaximize() {

379 function test_windowMaximize() {

295− var apps = ["unity8-dash", "dialer-app", "camera-app"];

380+ var dialerDelegate = startApplication("dialer-app");

296− apps.forEach(startApplication);

381+ startApplication("camera-app");

297− var appName = "dialer-app";

382+

298− var appDelegate = findChild(desktopStage, "appDelegate_" + appName);

299− verify(appDelegate);

300− ApplicationManager.focusApplication(appName);

383+ ApplicationManager.focusApplication("dialer-app");

301 keyClick(Qt.Key_Up, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Up shortcut to maximize

384 keyClick(Qt.Key_Up, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Up shortcut to maximize

302− tryCompare(appDelegate, "maximized", true);

385+ tryCompare(dialerDelegate, "maximized", true);

303− tryCompare(appDelegate, "minimized", false);

386+ tryCompare(dialerDelegate, "minimized", false);

304 }

387 }

305

388

306 function test_windowMaximizeLeft() {

389 function test_windowMaximizeLeft() {

307− var apps = ["unity8-dash", "dialer-app", "camera-app"];

390+ var dialerDelegate = startApplication("dialer-app");

308− apps.forEach(startApplication);

391+ startApplication("camera-app");

309− var appName = "dialer-app";

392+

310− var appDelegate = findChild(desktopStage, "appDelegate_" + appName);

311− verify(appDelegate);

312− ApplicationManager.focusApplication(appName);

393+ ApplicationManager.focusApplication("dialer-app");

313 keyClick(Qt.Key_Left, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Left shortcut to maximizeLeft

394 keyClick(Qt.Key_Left, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Left shortcut to maximizeLeft

314− tryCompare(appDelegate, "maximized", false);

395+ tryCompare(dialerDelegate, "maximized", false);

315− tryCompare(appDelegate, "minimized", false);

396+ tryCompare(dialerDelegate, "minimized", false);

316− tryCompare(appDelegate, "maximizedLeft", true);

397+ tryCompare(dialerDelegate, "maximizedLeft", true);

317− tryCompare(appDelegate, "maximizedRight", false);

398+ tryCompare(dialerDelegate, "maximizedRight", false);

318 }

399 }

319

400

320 function test_windowMaximizeRight() {

401 function test_windowMaximizeRight() {

321− var apps = ["unity8-dash", "dialer-app", "camera-app"];

402+ var dialerDelegate = startApplication("dialer-app");

322− apps.forEach(startApplication);

403+ startApplication("camera-app");

323− var appName = "dialer-app";

404+

324− var appDelegate = findChild(desktopStage, "appDelegate_" + appName);

325− verify(appDelegate);

326− ApplicationManager.focusApplication(appName);

405+ ApplicationManager.focusApplication("dialer-app");

327 keyClick(Qt.Key_Right, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Right shortcut to maximizeRight

406 keyClick(Qt.Key_Right, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Right shortcut to maximizeRight

328− tryCompare(appDelegate, "maximized", false);

407+ tryCompare(dialerDelegate, "maximized", false);

329− tryCompare(appDelegate, "minimized", false);

408+ tryCompare(dialerDelegate, "minimized", false);

330− tryCompare(appDelegate, "maximizedLeft", false);

409+ tryCompare(dialerDelegate, "maximizedLeft", false);

331− tryCompare(appDelegate, "maximizedRight", true);

410+ tryCompare(dialerDelegate, "maximizedRight", true);

332 }

411 }

333

412

334 function test_windowMinimize() {

413 function test_windowMinimize() {

335− var apps = ["unity8-dash", "dialer-app", "camera-app"];

414+ var dialerDelegate = startApplication("dialer-app");

336− apps.forEach(startApplication);

415+ startApplication("camera-app");

337− var appName = "dialer-app";

416+

338− var appDelegate = findChild(desktopStage, "appDelegate_" + appName);

339− verify(appDelegate);

340− ApplicationManager.focusApplication(appName);

417+ ApplicationManager.focusApplication("dialer-app");

341 keyClick(Qt.Key_Down, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Down shortcut to minimize

418 keyClick(Qt.Key_Down, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Down shortcut to minimize

342− tryCompare(appDelegate, "maximized", false);

419+ tryCompare(dialerDelegate, "maximized", false);

343− tryCompare(appDelegate, "minimized", true);

420+ tryCompare(dialerDelegate, "minimized", true);

344 verify(ApplicationManager.focusedApplicationId != ""); // verify we don't lose focus when minimizing an app

421 verify(ApplicationManager.focusedApplicationId != ""); // verify we don't lose focus when minimizing an app

345 }

422 }

346

423

347 function test_windowMinimizeAll() {

424 function test_windowMinimizeAll() {

348 var apps = ["unity8-dash", "dialer-app", "camera-app"];

425 var apps = ["unity8-dash", "dialer-app", "camera-app"];

349 apps.forEach(startApplication);

426 apps.forEach(startApplication);

350− verify(ApplicationManager.count == 3);

427+ verify(topSurfaceList.count == 3);

351 keyClick(Qt.Key_D, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+D shortcut to minimize all

428 keyClick(Qt.Key_D, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+D shortcut to minimize all

352 tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify no app is focused

429 tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify no app is focused

353 }

430 }

354

431

355 function test_windowClose() {

432 function test_windowClose() {

356− var apps = ["unity8-dash", "dialer-app", "camera-app"];

433+ var dialerSurfaceId = topSurfaceList.nextId;

357− apps.forEach(startApplication);

434+ var dialerDelegate = startApplication("dialer-app");

435+ verify(topSurfaceList.indexForId(dialerSurfaceId) !== -1);

436+ startApplication("gmail-webapp");

358− verify(ApplicationManager.count == 3);

437+ verify(topSurfaceList.count == 3);

359− var appName = "dialer-app";

438+

360− var appDelegate = findChild(desktopStage, "appDelegate_" + appName);

439+ mouseClick(dialerDelegate);

361− verify(appDelegate);

440+

362− ApplicationManager.focusApplication(appName);

441+ var desktopStagePriv = findInvisibleChild(desktopStage, "DesktopStagePrivate");

442+ tryCompare(desktopStagePriv, "focusedAppDelegate", dialerDelegate);

443+

363 keyClick(Qt.Key_F4, Qt.AltModifier); // Alt+F4 shortcut to close

444 keyClick(Qt.Key_F4, Qt.AltModifier); // Alt+F4 shortcut to close

445+

364− verify(ApplicationManager.count == 2); // verify the app is gone

446+ // verify the surface is gone

365− verify(ApplicationManager.findApplication(appName) === null); // and it's not in running apps

447+ tryCompare(topSurfaceList, "count", 2);

448+ verify(topSurfaceList.indexForId(dialerSurfaceId) === -1);

366 }

449 }

367

450

368 function test_smashCursorKeys() {

451 function test_smashCursorKeys() {

369− var apps = ["unity8-dash", "dialer-app", "camera-app"];

452+ var apps = ["dialer-app", "gmail-webapp"];

370 apps.forEach(startApplication);

453 apps.forEach(startApplication);

371− verify(ApplicationManager.count == 3);

454+ verify(topSurfaceList.count == 3);

372 keyClick(Qt.Key_D, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+D shortcut to minimize all

455 keyClick(Qt.Key_D, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+D shortcut to minimize all

373− tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify no app is focused

456+ tryCompare(MirFocusController, "focusedSurface", null); // verify no surface is focused

374

457

375 // now try pressing all 4 arrow keys + ctrl + meta

458 // now try pressing all 4 arrow keys + ctrl + meta

376 keyClick(Qt.Key_Up | Qt.Key_Down | Qt.Key_Left | Qt.Key_Right, Qt.MetaModifier|Qt.ControlModifier); // smash it!!!

459 keyClick(Qt.Key_Up | Qt.Key_Down | Qt.Key_Left | Qt.Key_Right, Qt.MetaModifier|Qt.ControlModifier); // smash it!!!

377− tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify still no app is focused

460+ tryCompare(MirFocusController, "focusedSurface", null); // verify still no surface is focused

378 }

461 }

379

462

380 function test_minimizeApplicationHidesSurface() {

463 function test_minimizeApplicationHidesSurface() {

381− var dashApp = startApplication("unity8-dash");

464+ compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

465+ var dashSurface = topSurfaceList.surfaceAt(0);

466+ var dashSurfaceId = topSurfaceList.idAt(0);

382

467

383− var dashDelegate = findChild(desktopStage, "appDelegate_unity8-dash");

468+ var decoratedWindow = findDecoratedWindow(dashSurfaceId);

384− verify(dashDelegate);

469+ verify(decoratedWindow);

385

470

471+ tryCompare(dashSurface, "visible", true);

386− findChild(dashDelegate, "decoratedWindow").minimize();

472+ decoratedWindow.minimize();

387− tryCompare(dashApp.session.lastSurface, "visible", false);

473+ tryCompare(dashSurface, "visible", false);

388 }

474 }

389

475

390 function test_maximizeApplicationHidesSurfacesBehindIt() {

476 function test_maximizeApplicationHidesSurfacesBehindIt() {

391− var dashApp = startApplication("unity8-dash");

477+ var dashDelegate = startApplication("unity8-dash");

392− var dialerApp = startApplication("dialer-app");

478+ var dialerDelegate = startApplication("dialer-app");

393− var gmailApp = startApplication("gmail-webapp");

479+ var gmailDelegate = startApplication("gmail-webapp");

394

480

395− var dashDelegate = findChild(desktopStage, "appDelegate_unity8-dash");

396− verify(dashDelegate);

397− var dialerDelegate = findChild(desktopStage, "appDelegate_dialer-app");

398− verify(dialerDelegate);

399− var gmailDelegate = findChild(desktopStage, "appDelegate_gmail-webapp");

400− verify(gmailDelegate);

401−

402− // maximize

481+ // maximize without raising

403 dialerDelegate.maximize();

482 dialerDelegate.maximize();

404 tryCompare(dialerDelegate, "visuallyMaximized", true);

483 tryCompare(dialerDelegate, "visuallyMaximized", true);

405

484

406− tryCompare(dashApp.session.lastSurface, "visible", false);

485+ tryCompare(dashDelegate.surface, "visible", false);

407− compare(gmailApp.session.lastSurface.visible, true);

486+ compare(gmailDelegate.surface.visible, true);

408

487

409− // restore

488+ // restore without raising

410 dialerDelegate.restoreFromMaximized();

489 dialerDelegate.restoreFromMaximized();

411− compare(dashApp.session.lastSurface.visible, true);

490+ compare(dashDelegate.surface.visible, true);

412− compare(gmailApp.session.lastSurface.visible, true);

491+ compare(gmailDelegate.surface.visible, true);

413 }

492 }

414

493

415 function test_applicationsBecomeVisibleWhenOccludingAppRemoved() {

494 function test_applicationsBecomeVisibleWhenOccludingAppRemoved() {

416− var dashApp = startApplication("unity8-dash");

495+ var dashApp = topSurfaceList.applicationAt(0);

417− var dashDelegate = findChild(desktopStage, "appDelegate_unity8-dash");

418− verify(dashDelegate);

419

496

420− var dialerApp = startApplication("dialer-app");

497+ var dialerSurfaceId = topSurfaceList.nextId;

421− var dialerDelegate = findChild(desktopStage, "appDelegate_dialer-app");

498+ var dialerDelegate = startApplication("dialer-app");

422 verify(dialerDelegate);

499 verify(dialerDelegate);

500+ var dialerApp = dialerDelegate.application;

423

501

424 var dialerMaximizeButton = findChild(dialerDelegate, "maximizeWindowButton");

502 var dialerMaximizeButton = findChild(dialerDelegate, "maximizeWindowButton");

425 verify(dialerMaximizeButton);

503 verify(dialerMaximizeButton);

426 mouseClick(dialerMaximizeButton);

504 mouseClick(dialerMaximizeButton);

427

505

428− var mapApp = startApplication("map");

506+ var mapSurfaceId = topSurfaceList.nextId;

429− var mapDelegate = findChild(desktopStage, "appDelegate_map");

507+ var mapDelegate = startApplication("map");

430 verify(mapDelegate);

508 verify(mapDelegate);

509+ var mapApp = mapDelegate.application;

431

510

432− var gmailApp = startApplication("gmail-webapp");

511+ var gmailSurfaceId = topSurfaceList.nextId;

433− var gmailDelegate = findChild(desktopStage, "appDelegate_gmail-webapp");

512+ var gmailDelegate = startApplication("gmail-webapp");

434 verify(gmailDelegate);

513 verify(gmailDelegate);

435

514

436 var gmailMaximizeButton = findChild(gmailDelegate, "maximizeWindowButton");

515 var gmailMaximizeButton = findChild(gmailDelegate, "maximizeWindowButton");

@@ -440,29 +519,27 @@ Item {

440 tryCompare(dialerDelegate, "visuallyMaximized", true);

519 tryCompare(dialerDelegate, "visuallyMaximized", true);

441 tryCompare(gmailDelegate, "visuallyMaximized", true);

520 tryCompare(gmailDelegate, "visuallyMaximized", true);

442

521

443− tryCompare(dashApp.session.lastSurface, "visible", false);

522+ tryCompare(dashApp.surfaceList.get(0), "visible", false);

444− tryCompare(dialerApp.session.lastSurface, "visible", false);

523+ tryCompare(dialerApp.surfaceList.get(0), "visible", false);

445− tryCompare(mapApp.session.lastSurface, "visible", false);

524+ tryCompare(mapApp.surfaceList.get(0), "visible", false);

446

525

447 ApplicationManager.stopApplication("gmail-webapp");

526 ApplicationManager.stopApplication("gmail-webapp");

448

527

449− compare(mapApp.session.lastSurface.visible, true);

528+ tryCompare(mapApp.surfaceList.get(0), "visible", true);

450− tryCompare(dialerApp.session.lastSurface, "visible", true);

529+ tryCompare(dialerApp.surfaceList.get(0), "visible", true);

451− tryCompare(dashApp.session.lastSurface, "visible", false); // still occluded by maximised dialer

530+ tryCompare(dashApp.surfaceList.get(0), "visible", false); // still occluded by maximised dialer

452 }

531 }

453

532

454 function test_maximisedAppStaysVisibleWhenAppStarts() {

533 function test_maximisedAppStaysVisibleWhenAppStarts() {

455− var dashApp = startApplication("unity8-dash");

534+ var dashDelegate = startApplication("unity8-dash");

456− var dashDelegate = findChild(desktopStage, "appDelegate_unity8-dash");

535+

457− verify(dashDelegate);

458 // maximize

536 // maximize

459 var dashMaximizeButton = findChild(dashDelegate, "maximizeWindowButton");

537 var dashMaximizeButton = findChild(dashDelegate, "maximizeWindowButton");

460 verify(dashMaximizeButton);

538 verify(dashMaximizeButton);

461 mouseClick(dashMaximizeButton);

539 mouseClick(dashMaximizeButton);

462 tryCompare(dashDelegate, "visuallyMaximized", true);

540 tryCompare(dashDelegate, "visuallyMaximized", true);

463

541

464− var dialerApp = startApplication("dialer-app");

542+ var dialerDelegate = startApplication("dialer-app");

465− var dialerDelegate = findChild(desktopStage, "appDelegate_dialer-app");

466 verify(dialerDelegate);

543 verify(dialerDelegate);

467

544

468 compare(dialerDelegate.visible, true, "Dialer should be visible");

545 compare(dialerDelegate.visible, true, "Dialer should be visible");

@@ -470,14 +547,11 @@ Item {

470 }

547 }

471

548

472 function test_occlusionWithMultipleMaximized() {

549 function test_occlusionWithMultipleMaximized() {

473− var dashApp = startApplication("unity8-dash");

550+ var dashAppDelegate = startApplication("unity8-dash");

474− var dashAppDelegate = findChild(desktopStage, "appDelegate_unity8-dash");

475

551

476− var dialerApp = startApplication("dialer-app");

552+ var dialerAppDelegate = startApplication("dialer-app");

477− var dialerAppDelegate = findChild(desktopStage, "appDelegate_dialer-app");

478

553

479− var facebookApp = startApplication("facebook-webapp");

554+ var facebookAppDelegate = startApplication("facebook-webapp");

480− var facebookAppDelegate = findChild(desktopStage, "appDelegate_facebook-webapp");

481

555

482 // all of them are in restored state now. all should be visible

556 // all of them are in restored state now. all should be visible

483 tryCompare(dashAppDelegate, "visible", true);

557 tryCompare(dashAppDelegate, "visible", true);

@@ -510,20 +584,15 @@ Item {

510 }

584 }

511

585

512 function test_dropShadow() {

586 function test_dropShadow() {

513− // verify the drop shadow is not visible initially

514− verify(PanelState.dropShadow == false);

515−

516 // start an app, maximize it

587 // start an app, maximize it

517− var facebookApp = startApplication("facebook-webapp");

588+ var facebookAppDelegate = startApplication("facebook-webapp");

518− var facebookAppDelegate = findChild(desktopStage, "appDelegate_facebook-webapp");

519 facebookAppDelegate.maximize();

589 facebookAppDelegate.maximize();

520

590

521 // verify the drop shadow is still not visible

591 // verify the drop shadow is still not visible

522 verify(PanelState.dropShadow == false);

592 verify(PanelState.dropShadow == false);

523

593

524 // start a foreground app, not maximized

594 // start a foreground app, not maximized

525− var dialerApp = startApplication("dialer-app");

595+ var dialerAppDelegate = startApplication("dialer-app");

526− var dialerAppDelegate = findChild(desktopStage, "appDelegate_dialer-app");

527

596

528 // verify the drop shadow becomes visible

597 // verify the drop shadow becomes visible

529 verify(PanelState.dropShadow == true);

598 verify(PanelState.dropShadow == true);

@@ -532,7 +601,7 @@ Item {

532 ApplicationManager.stopApplication("facebook-webapp");

601 ApplicationManager.stopApplication("facebook-webapp");

533

602

534 // verify the drop shadow is gone

603 // verify the drop shadow is gone

535− verify(PanelState.dropShadow == false);

604+ tryCompare(PanelState, "dropShadow", false);

536 }

605 }

537 }

606 }

538}

607}

tests/qmltests/Stages/tst_PhoneStage.qml+255−82

@@ -1,5 +1,5 @@

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

@@ -22,8 +22,10 @@ import "../../../qml/Components"

22import "../../../qml/Stages"

23import Ubuntu.Components 1.3

24import Unity.Application 0.1

25+import WindowManager 0.1

26Item {

27Item {

28+ id: root

27 width: units.gu(70)

29 width: units.gu(70)

28 height: units.gu(70)

30 height: units.gu(70)

@@ -38,63 +40,40 @@ Item {

38 interactive: true

40 interactive: true

39 shellOrientation: Qt.PortraitOrientation

41 shellOrientation: Qt.PortraitOrientation

40 orientations: Orientations {}

42 orientations: Orientations {}

43+ applicationManager: ApplicationManager

44+ topLevelSurfaceList: TopLevelSurfaceList {

45+ id: topLevelSurfaceList

46+ applicationsModel: ApplicationManager

47+ }

41 }

48 }

50+ Flickable {

51+ contentHeight: controlRect.height

52+

53+ anchors.top: root.top

54+ anchors.bottom: root.bottom

55+ anchors.right: root.right

56+ width: units.gu(30)

43− Rectangle {

57+ Rectangle {

44− anchors { fill: parent; leftMargin: phoneStage.width }

58+ id: controlRect

45−

59+ anchors { left: parent.left; right: parent.right }

60+ height: childrenRect.height + units.gu(2)

61+ color: "darkGrey"

46− Column {

62+ Column {

47− id: buttons

48− anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

63+ anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

49− spacing: units.gu(1)

64+ spacing: units.gu(1)

50− Button {

65+ EdgeBarrierControls {

51− anchors { left: parent.left; right: parent.right }

66+ id: edgeBarrierControls

52− text: "Add App"

67+ text: "Drag here to pull out spread"

53− activeFocusOnPress: false

68+ backgroundColor: "blue"

54− onClicked: {

69+ onDragged: { phoneStage.pushRightEdge(amount); }

55− testCase.addApps();

70+ Component.onCompleted: {

56− }

71+ edgeBarrierControls.target = testCase.findChild(phoneStage, "edgeBarrierController");

57− }

72+ }

58− Button {

59− anchors { left: parent.left; right: parent.right }

60− text: "Remove Selected"

61− activeFocusOnPress: false

62− onClicked: {

63− ApplicationManager.stopApplication(ApplicationManager.get(appList.selectedAppIndex).appId);

64− }

65− }

66− Button {

67− anchors { left: parent.left; right: parent.right }

68− text: "Stop Selected"

69− activeFocusOnPress: false

70− onClicked: {

71− ApplicationManager.get(appList.selectedAppIndex).setState(ApplicationInfoInterface.Stopped);

72 }

73 }

73− }

74+ Repeater {

74− EdgeBarrierControls {

75− id: edgeBarrierControls

76− text: "Drag here to pull out spread"

77− backgroundColor: "blue"

78− onDragged: { phoneStage.pushRightEdge(amount); }

79− Component.onCompleted: {

80− edgeBarrierControls.target = testCase.findChild(phoneStage, "edgeBarrierController");

81− }

82− }

83− }

84− ListView {

85− id: appList

86− property int selectedAppIndex

87− anchors { left: parent.left; right: parent.right; top: buttons.bottom; bottom: parent.bottom }

88− boundsBehavior: Flickable.StopAtBounds

89− model: ApplicationManager

75+ model: ApplicationManager.availableApplications

90− delegate: Rectangle {

76+ ApplicationCheckBox { appId: modelData }

91− anchors { left: parent.left; right: parent.right }

92− height: units.gu(2)

93− color: appList.selectedAppIndex === model.index ? "red" : "white"

94− Text { anchors.fill: parent; text: model.appId }

95− MouseArea {

96− anchors.fill: parent

97− onPressed: { appList.selectedAppIndex = model.index; }

98 }

77 }

99 }

78 }

100 }

79 }

@@ -105,18 +84,41 @@ Item {

105 name: "PhoneStage"

84 name: "PhoneStage"

106 when: windowShown

85 when: windowShown

107

87+ function findAppWindowForSurfaceId(surfaceId) {

88+ var delegateObjectName = "spreadDelegate_" + surfaceId;

89+ var spreadDelegate = findChild(phoneStage, delegateObjectName);

90+ if (!spreadDelegate) {

91+ console.warn("Failed to find " + delegateObjectName + " in phoneStage ("+phoneStage+")");

92+ return null;

93+ }

94+ var appWindow = findChild(spreadDelegate, "appWindow");

95+ return appWindow;

96+ }

97+

98+ // Waits until ApplicationWindow has moved from showing a splash screen to displaying

99+ // the application surface.

100+ function waitUntilAppSurfaceShowsUp(surfaceId) {

101+ var appWindow = findAppWindowForSurfaceId(surfaceId);

102+ verify(appWindow);

103+ var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

104+ verify(appWindowStates);

105+ tryCompare(appWindowStates, "state", "surface");

106+ }

107+

108 function addApps(count) {

109 if (count == undefined) count = 1;

110 for (var i = 0; i < count; i++) {

111+ var appSurfaceId = topLevelSurfaceList.nextId;

111 var app = ApplicationManager.startApplication(ApplicationManager.availableApplications[ApplicationManager.count])

112 var app = ApplicationManager.startApplication(ApplicationManager.availableApplications[ApplicationManager.count])

112 tryCompare(app, "state", ApplicationInfoInterface.Running)

113 tryCompare(app, "state", ApplicationInfoInterface.Running)

113 var spreadView = findChild(phoneStage, "spreadView");

114 var spreadView = findChild(phoneStage, "spreadView");

114 tryCompare(spreadView, "contentX", -spreadView.shift);

115 tryCompare(spreadView, "contentX", -spreadView.shift);

116+ waitUntilAppSurfaceShowsUp(appSurfaceId);

115 waitForRendering(phoneStage)

117 waitForRendering(phoneStage)

116 }

118 }

117 }

119 }

118

120

119− function goToSpread() {

121+ function performEdgeSwipeToShowAppSpread() {

120 var spreadView = findChild(phoneStage, "spreadView");

122 var spreadView = findChild(phoneStage, "spreadView");

121

123

122 // Keep it inside the PhoneStage otherwise the controls on the right side will

124 // Keep it inside the PhoneStage otherwise the controls on the right side will

@@ -130,9 +132,46 @@ Item {

130 true /* beginTouch */, true /* endTouch */, units.gu(10), 50);

132 true /* beginTouch */, true /* endTouch */, units.gu(10), 50);

131

133

132 tryCompare(spreadView, "phase", 2);

134 tryCompare(spreadView, "phase", 2);

135+ tryCompare(spreadView, "flicking", false);

136+ tryCompare(spreadView, "moving", false);

133 waitForRendering(phoneStage);

137 waitForRendering(phoneStage);

134 }

138 }

135

139

140+ function swipeSurfaceUpwards(surfaceId) {

141+ var appWindow = findAppWindowForSurfaceId(surfaceId);

142+ verify(appWindow);

143+

144+ // Swipe from the left side of the surface as it's the one most likely

145+ // to not be covered by other surfaces when they're all being shown in the spread

146+ touchFlick(appWindow,

147+ appWindow.width * 0.1, appWindow.height / 2,

148+ appWindow.width * 0.1, -appWindow.height / 2);

149+ }

150+

151+ function switchToSurface(targetSurfaceId) {

152+ performEdgeSwipeToShowAppSpread();

153+

154+ waitUntilAppDelegateStopsMoving(targetSurfaceId);

155+

156+ // TODO: won't work if there are many items in the spread. in this case

157+ // you might have to drag the list to the right or left a bit to better

158+ // expose the target surface. Improve this code if needed.

159+ var targetAppWindow = findAppWindowForSurfaceId(targetSurfaceId);

160+ verify(targetAppWindow);

161+ tap(targetAppWindow, 10, 10);

162+ }

163+

164+ function waitUntilAppDelegateStopsMoving(targetSurfaceId)

165+ {

166+ var targetAppDelegate = findChild(phoneStage, "spreadDelegate_" + targetSurfaceId);

167+ verify(targetAppDelegate);

168+ var lastValue = undefined;

169+ do {

170+ lastValue = targetAppDelegate.animatedProgress;

171+ wait(300);

172+ } while (lastValue != targetAppDelegate.animatedProgress);

173+ }

174+

136 function test_shortFlick() {

175 function test_shortFlick() {

137 addApps(2)

176 addApps(2)

138 var startX = phoneStage.width - units.gu(1);

177 var startX = phoneStage.width - units.gu(1);

@@ -200,7 +239,7 @@ Item {

200 tryCompare(spreadView, "phase", data.targetPhase)

239 tryCompare(spreadView, "phase", data.targetPhase)

201

240

202 if (data.targetPhase == 2) {

241 if (data.targetPhase == 2) {

203− var app2 = findChild(spreadView, "appDelegate2");

242+ var app2 = findChild(spreadView, "spreadDelegate_" + topLevelSurfaceList.idAt(2));

204 tryCompare(app2, "swipeToCloseEnabled", true);

243 tryCompare(app2, "swipeToCloseEnabled", true);

205 mouseClick(app2, units.gu(1), units.gu(1));

244 mouseClick(app2, units.gu(1), units.gu(1));

206 }

245 }

@@ -226,11 +265,11 @@ Item {

226

265

227 var spreadView = findChild(phoneStage, "spreadView");

266 var spreadView = findChild(phoneStage, "spreadView");

228

267

229− goToSpread();

268+ performEdgeSwipeToShowAppSpread();

230

269

231 tryCompare(spreadView, "phase", 2);

270 tryCompare(spreadView, "phase", 2);

232

271

233− var tile = findChild(spreadView, "appDelegate" + data.index);

272+ var tile = findChild(spreadView, "spreadDelegate_" + topLevelSurfaceList.idAt(data.index));

234 var appId = ApplicationManager.get(data.index).appId;

273 var appId = ApplicationManager.get(data.index).appId;

235

274

236 if (tile.mapToItem(spreadView).x > spreadView.width) {

275 if (tile.mapToItem(spreadView).x > spreadView.width) {

@@ -266,7 +305,7 @@ Item {

266 var spreadView = findChild(phoneStage, "spreadView");

305 var spreadView = findChild(phoneStage, "spreadView");

267 var selectedApp = ApplicationManager.get(data.index);

306 var selectedApp = ApplicationManager.get(data.index);

268

307

269− goToSpread();

308+ performEdgeSwipeToShowAppSpread();

270

309

271 phoneStage.select(selectedApp.appId);

310 phoneStage.select(selectedApp.appId);

272

311

@@ -280,7 +319,7 @@ Item {

280

319

281 var focusedAppId = ApplicationManager.focusedApplicationId;

320 var focusedAppId = ApplicationManager.focusedApplicationId;

282

321

283− goToSpread();

322+ performEdgeSwipeToShowAppSpread();

284

323

285 mouseClick(phoneStage, units.gu(1), units.gu(1));

324 mouseClick(phoneStage, units.gu(1), units.gu(1));

286

325

@@ -292,15 +331,26 @@ Item {

292 compare(focusedAppId, ApplicationManager.focusedApplicationId);

331 compare(focusedAppId, ApplicationManager.focusedApplicationId);

293 }

332 }

294

333

334+ function init() {

335+ // wait until unity8-dash is up and running.

336+ // it's started automatically by ApplicationManager mock implementation

337+ tryCompare(ApplicationManager, "count", 1);

338+ var dashApp = ApplicationManager.findApplication("unity8-dash");

339+ verify(dashApp);

340+ tryCompare(dashApp, "state", ApplicationInfoInterface.Running);

341+ }

342+

295 function cleanup() {

343 function cleanup() {

296− while (ApplicationManager.count > 1) {

344+ killApps();

297− var oldCount = ApplicationManager.count;

345+

298− var closingIndex = ApplicationManager.focusedApplicationId == "unity8-dash" ? 1 : 0

299− ApplicationManager.stopApplication(ApplicationManager.get(closingIndex).appId)

300− tryCompare(ApplicationManager, "count", oldCount - 1)

301− }

302 phoneStage.shellOrientationAngle = 0;

346 phoneStage.shellOrientationAngle = 0;

303 phoneStage.select(ApplicationManager.get(0).appId);

347 phoneStage.select(ApplicationManager.get(0).appId);

348+

349+ // wait for PhoneStage to stabilize back into its initial state

350+ var spreadView = findChild(phoneStage, "spreadView");

351+ while (spreadView.phase !== 0 || spreadView.contentX !== -spreadView.shift) {

352+ wait(50);

353+ }

304 }

354 }

305

355

306 function test_focusNewTopMostAppAfterFocusedOneClosesItself() {

356 function test_focusNewTopMostAppAfterFocusedOneClosesItself() {

@@ -323,16 +373,16 @@ Item {

323 function test_cantCloseWhileSnapping() {

373 function test_cantCloseWhileSnapping() {

324 addApps(2);

374 addApps(2);

325

375

326− goToSpread();

376+ performEdgeSwipeToShowAppSpread();

327

377

328 var spreadView = findChild(phoneStage, "spreadView");

378 var spreadView = findChild(phoneStage, "spreadView");

329 var selectedApp = ApplicationManager.get(2);

379 var selectedApp = ApplicationManager.get(2);

330

380

331− goToSpread();

381+ performEdgeSwipeToShowAppSpread();

332

382

333− var app0 = findChild(spreadView, "appDelegate0");

383+ var app0 = findChild(spreadView, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

334− var app1 = findChild(spreadView, "appDelegate1");

384+ var app1 = findChild(spreadView, "spreadDelegate_" + topLevelSurfaceList.idAt(1));

335− var app2 = findChild(spreadView, "appDelegate2");

385+ var app2 = findChild(spreadView, "spreadDelegate_" + topLevelSurfaceList.idAt(2));

336

386

337 var dragArea0 = findChild(app0, "dragArea");

387 var dragArea0 = findChild(app0, "dragArea");

338 var dragArea1 = findChild(app1, "dragArea");

388 var dragArea1 = findChild(app1, "dragArea");

@@ -382,10 +432,10 @@ Item {

382 addApps(2);

432 addApps(2);

383

433

384 if (data.inSpread) {

434 if (data.inSpread) {

385− goToSpread();

435+ performEdgeSwipeToShowAppSpread();

386 }

436 }

387

437

388− var focusedDelegate = findChild(phoneStage, "appDelegate0");

438+ var focusedDelegate = findChild(phoneStage, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

389 phoneStage.inverseProgress = data.leftEdgeDragWidth;

439 phoneStage.inverseProgress = data.leftEdgeDragWidth;

390

440

391 tryCompare(focusedDelegate, "x", data.shouldMoveApp ? data.leftEdgeDragWidth : 0);

441 tryCompare(focusedDelegate, "x", data.shouldMoveApp ? data.leftEdgeDragWidth : 0);

@@ -398,9 +448,9 @@ Item {

398 function test_focusedAppIsTheOnlyRunningApp() {

448 function test_focusedAppIsTheOnlyRunningApp() {

399 addApps(2);

449 addApps(2);

400

450

401− var delegateA = findChild(phoneStage, "appDelegate0");

451+ var delegateA = findChild(phoneStage, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

402 verify(delegateA);

452 verify(delegateA);

403− var delegateB = findChild(phoneStage, "appDelegate1");

453+ var delegateB = findChild(phoneStage, "spreadDelegate_" + topLevelSurfaceList.idAt(1));

404 verify(delegateB);

454 verify(delegateB);

405

455

406 // A is focused and running, B is unfocused and suspended

456 // A is focused and running, B is unfocused and suspended

@@ -410,7 +460,7 @@ Item {

410 compare(delegateB.application.requestedState, ApplicationInfoInterface.RequestedSuspended);

460 compare(delegateB.application.requestedState, ApplicationInfoInterface.RequestedSuspended);

411

461

412 // Switch foreground/focused appp from A to B

462 // Switch foreground/focused appp from A to B

413− goToSpread();

463+ performEdgeSwipeToShowAppSpread();

414 phoneStage.select(delegateB.application.appId);

464 phoneStage.select(delegateB.application.appId);

415

465

416 // Now it's the other way round

466 // Now it's the other way round

@@ -424,14 +474,14 @@ Item {

424 function test_dashRemainsRunningIfStageIsToldSo() {

474 function test_dashRemainsRunningIfStageIsToldSo() {

425 addApps(1);

475 addApps(1);

426

476

427− var delegateDash = findChild(phoneStage, "appDelegate1");

477+ var delegateDash = findChild(phoneStage, "spreadDelegate_" + topLevelSurfaceList.idAt(1));

428 verify(delegateDash);

478 verify(delegateDash);

429 compare(delegateDash.application.appId, "unity8-dash");

479 compare(delegateDash.application.appId, "unity8-dash");

430

480

431− var delegateOther = findChild(phoneStage, "appDelegate0");

481+ var delegateOther = findChild(phoneStage, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

432 verify(delegateOther);

482 verify(delegateOther);

433

483

434− goToSpread();

484+ performEdgeSwipeToShowAppSpread();

435 phoneStage.select("unity8-dash");

485 phoneStage.select("unity8-dash");

436

486

437 tryCompare(delegateDash, "focus", true);

487 tryCompare(delegateDash, "focus", true);

@@ -439,7 +489,7 @@ Item {

439 compare(delegateOther.focus, false);

489 compare(delegateOther.focus, false);

440 compare(delegateOther.application.requestedState, ApplicationInfoInterface.RequestedSuspended);

490 compare(delegateOther.application.requestedState, ApplicationInfoInterface.RequestedSuspended);

441

491

442− goToSpread();

492+ performEdgeSwipeToShowAppSpread();

443 phoneStage.select(delegateOther.application.appId);

493 phoneStage.select(delegateOther.application.appId);

444

494

445 // The other app gets focused and running but dash is kept running despite being unfocused

495 // The other app gets focused and running but dash is kept running despite being unfocused

@@ -452,7 +502,7 @@ Item {

452 function test_foregroundAppIsSuspendedWhenStageIsSuspended() {

502 function test_foregroundAppIsSuspendedWhenStageIsSuspended() {

453 addApps(1);

503 addApps(1);

454

504

455− var delegate = findChild(phoneStage, "appDelegate0");

505+ var delegate = findChild(phoneStage, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

456 verify(delegate);

506 verify(delegate);

457

507

458 compare(delegate.focus, true);

508 compare(delegate.focus, true);

@@ -476,5 +526,128 @@ Item {

476 }

526 }

477 tryCompare(spreadView, "phase", 2);

527 tryCompare(spreadView, "phase", 2);

478 }

528 }

529+

530+ function test_closeSurfaceOfMultiSurfaceApp() {

531+ var surface1Id = topLevelSurfaceList.nextId;

532+ var webbrowserApp = ApplicationManager.startApplication("webbrowser-app");

533+ waitUntilAppSurfaceShowsUp(surface1Id);

534+

535+ var surface2Id = topLevelSurfaceList.nextId;

536+ verify(surface1Id !== surface2Id); // sanity checking

537+ webbrowserApp.createSurface();

538+ waitUntilAppSurfaceShowsUp(surface2Id);

539+

540+ performEdgeSwipeToShowAppSpread();

541+

542+ var appDelegate = findChild(phoneStage, "spreadDelegate_" + surface1Id);

543+ verify(appDelegate);

544+ tryCompare(appDelegate, "swipeToCloseEnabled", true);

545+

546+ compare(webbrowserApp.surfaceList.count, 2);

547+ compare(webbrowserApp.state, ApplicationInfoInterface.Running);

548+

549+ swipeSurfaceUpwards(surface1Id);

550+

551+ // Surface must eventually be gone

552+ tryCompareFunction(function() { return topLevelSurfaceList.indexForId(surface1Id); }, -1);

553+ tryCompare(webbrowserApp.surfaceList, "count", 1);

554+ compare(webbrowserApp.state, ApplicationInfoInterface.Running);

555+ }

556+

557+ /*

558+ 1- Suspended app gets killed behind the scenes, causing its surface to go zombie.

559+ 2- Surface gets screenshotted and removed. Its slot in the topLevelSurfaceList remains,

560+ though (so ApplicationWindow can display the screenshot in its place).

561+ 3- User taps on the screenshot of the long-gone surface.

562+

563+ Expected outcome:

564+ Application gets relaunched. Its new surface will seamlessly replace the screenshot.

565+ */

566+ function test_selectSuspendedAppWithoutSurface() {

567+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

568+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

569+ var dashSurface = topLevelSurfaceList.surfaceAt(0);

570+

571+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

572+ var webbrowserApp = ApplicationManager.startApplication("webbrowser-app");

573+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

574+

575+ switchToSurface(dashSurfaceId);

576+

577+ tryCompare(MirFocusController, "focusedSurface", dashSurface);

578+ tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

579+

580+ compare(webbrowserApp.surfaceList.count, 1);

581+

582+ // simulate the suspended app being killed by the out-of-memory daemon

583+ webbrowserApp.surfaceList.get(0).setLive(false);

584+

585+ // wait until the surface is gone

586+ tryCompare(webbrowserApp.surfaceList, "count", 0);

587+

588+ compare(topLevelSurfaceList.surfaceAt(topLevelSurfaceList.indexForId(webbrowserSurfaceId)), null);

589+

590+ switchToSurface(webbrowserSurfaceId);

591+

592+ // webbrowser should have been brought to front

593+ tryCompareFunction(function(){return topLevelSurfaceList.idAt(0);}, webbrowserSurfaceId);

594+

595+ // and it should eventually get a new surface and get resumed

596+ tryCompareFunction(function(){return topLevelSurfaceList.surfaceAt(0) !== null;}, true);

597+ compare(topLevelSurfaceList.count, 2); // still two top-level items

598+ tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

599+ compare(webbrowserApp.surfaceList.count, 1);

600+ }

601+

602+ /*

603+ 1 - user suspends an application (ie, focus a surface from a different application)

604+ 2 - That suspended application gets killed, causing its surface to go zombie

605+ 3 - user goes to spread and closes that zombie surface. Actually, by that time

606+ Tablet shell will be displaying a screenshot of it instead, so there's no

607+ MirSurface whatsoever backing it up.

608+ */

609+ function test_closeZombieSurface()

610+ {

611+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

612+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

613+ var dashSurface = topLevelSurfaceList.surfaceAt(0);

614+

615+ var webbrowserSurfaceId = topLevelSurfaceList.nextId;

616+ var webbrowserApp = ApplicationManager.startApplication("webbrowser-app");

617+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

618+

619+ switchToSurface(dashSurfaceId);

620+

621+ tryCompare(MirFocusController, "focusedSurface", dashSurface);

622+ tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

623+

624+ compare(webbrowserApp.surfaceList.count, 1);

625+

626+ // simulate the suspended app being killed by the out-of-memory daemon

627+ webbrowserApp.surfaceList.get(0).setLive(false);

628+

629+ // wait until the surface is gone

630+ tryCompare(webbrowserApp.surfaceList, "count", 0);

631+ compare(topLevelSurfaceList.surfaceAt(topLevelSurfaceList.indexForId(webbrowserSurfaceId)), null);

632+

633+ performEdgeSwipeToShowAppSpread();

634+

635+ {

636+ var appDelegate = findChild(phoneStage, "spreadDelegate_" + webbrowserSurfaceId);

637+ verify(appDelegate);

638+ tryCompare(appDelegate, "swipeToCloseEnabled", true);

639+ }

640+

641+ swipeSurfaceUpwards(webbrowserSurfaceId);

642+

643+ // webbrowser entry is nowhere to be seen

644+ tryCompareFunction(function(){return topLevelSurfaceList.indexForId(webbrowserSurfaceId);}, -1);

645+

646+ // nor is its app

647+ compare(ApplicationManager.findApplication("webbrowser-app"), null);

648+

649+ // only unity8-dash surface is left

650+ compare(topLevelSurfaceList.count, 1);

651+ }

479 }

652 }

480}

653}

tests/qmltests/Stages/tst_SessionContainer.qmldeleted−331

@@ -1,331 +0,0 @@

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−

17−import QtQuick 2.4

18−import QtQuick.Layouts 1.1

19−import QtTest 1.0

20−import Unity.Test 0.1 as UT

21−import Ubuntu.Components 1.3

22−import Unity.Application 0.1

23−import "../../../qml/Stages"

24−

25−Rectangle {

26− color: "red"

27− id: root

28− width: units.gu(80)

29− height: units.gu(70)

30−

31− Connections {

32− target: sessionContainerLoader.status === Loader.Ready ? sessionContainerLoader.item : null

33− onSessionChanged: {

34− sessionCheckbox.checked = sessionContainerLoader.item.session !== null

35− }

36− }

37−

38− Component {

39− id: sessionContainerComponent

40−

41− SessionContainer {

42− id: sessionContainer

43− anchors.fill: parent

44− focus: true

45− interactive: true

46− }

47− }

48−

49− Loader {

50− id: sessionContainerLoader

51− focus: true

52− anchors {

53− top: parent.top

54− bottom: parent.bottom

55− left: parent.left

56− }

57− width: units.gu(40)

58− sourceComponent: sessionContainerComponent

59− }

60−

61− Rectangle {

62− color: "white"

63− anchors {

64− top: parent.top

65− bottom: parent.bottom

66− left: sessionContainerLoader.right

67− right: parent.right

68− }

69−

70− ColumnLayout {

71− anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

72− spacing: units.gu(1)

73−

74− RowLayout {

75− Layout.fillWidth: true

76−

77− CheckBox {

78− id: sessionCheckbox;

79− checked: false;

80− activeFocusOnPress: false

81− onCheckedChanged: {

82− if (sessionContainerLoader.status !== Loader.Ready)

83− return;

84−

85− if (checked) {

86− var fakeSession = SessionManager.createSession("music-player", Qt.resolvedUrl("../Dash/artwork/music-player-design.png"));

87− sessionContainerLoader.item.session = fakeSession;

88− fakeSession.createSurface();

89− } else {

90− sessionContainerLoader.item.session.release();

91− }

92− }

93− }

94−

95− Label {

96− text: "session"

97− anchors.verticalCenter: parent.verticalCenter

98− }

99− }

100−

101− Rectangle {

102− border {

103− color: "black"

104− width: 1

105− }

106− anchors {

107− left: parent.left

108− right: parent.right

109− }

110− Layout.preferredHeight: sessionChildrenControl.height

111−

112− RecursingChildSessionControl {

113− id: sessionChildrenControl

114− anchors { left: parent.left; right: parent.right; }

115−

116− session: sessionContainerLoader.item ? sessionContainerLoader.item.session : null

117− }

118− }

119− }

120− }

121−

122− SignalSpy {

123− id: sessionSpy

124− target: SessionManager

125− signalName: "sessionStopping"

126− }

127−

128− UT.UnityTestCase {

129− id: testCase

130− name: "SessionContainer"

131−

132− function init() {

133− // reload our test subject to get it in a fresh state once again

134− sessionContainerLoader.active = false;

135− sessionCheckbox.checked = false;

136− sessionContainerLoader.active = true;

137−

138− tryCompare(sessionContainerLoader.item, "session", null);

139− sessionSpy.clear();

140− }

141−

142− when: windowShown

143−

144− function test_addChildSession_data() {

145− return [ { tag: "count=1", count: 1 },

146− { tag: "count=4", count: 4 } ];

147− }

148−

149− function test_addChildSession(data) {

150− sessionCheckbox.checked = true;

151− var sessionContainer = sessionContainerLoader.item;

152− compare(sessionContainer.childSessions.count(), 0);

153−

154− var i;

155− var sessions = [];

156− for (i = 0; i < data.count; i++) {

157− var session = ApplicationTest.addChildSession(sessionContainer.session,

158− "gallery",

159− true);

160− session.createSurface();

161− sessionContainer.session.addChildSession(session);

162− compare(sessionContainer.childSessions.count(), i+1);

163−

164− sessions.push(session);

165− }

166−

167− for (i = data.count-1; i >= 0; i--) {

168− ApplicationTest.removeSession(sessions[i]);

169− tryCompareFunction(function() { return sessionContainer.childSessions.count(); }, i);

170− }

171− tryCompare(sessionSpy, "count", data.count);

172− }

173−

174− function test_childSessionDestructionReturnsFocusToSiblingOrParent() {

175− sessionCheckbox.checked = true;

176− var sessionContainer = sessionContainerLoader.item;

177− compare(sessionContainer.childSessions.count(), 0);

178−

179− var i;

180− var sessions = [];

181− // 3 sessions should cover all edge cases

182− for(i = 0; i < 3; i++) {

183− var a_session = ApplicationTest.addChildSession(

184− sessionContainer.session, "gallery", true

185− )

186−

187− a_session.createSurface();

188− sessionContainer.session.addChildSession(a_session);

189− compare(sessionContainer.childSessions.count(), i + 1);

190−

191− sessions.push(a_session);

192− }

193−

194− var a_session;

195− while(a_session = sessions.pop()) {

196− compare(a_session.lastSurface.activeFocus, true);

197−

198− ApplicationTest.removeSurface(a_session.lastSurface);

199− ApplicationTest.removeSession(a_session);

200−

201− if (sessions.length > 0) {

202− // active focus should have gone to the yongest remaining sibling

203− var previousSiblingSurface = sessions[sessions.length - 1].lastSurface

204− tryCompare(previousSiblingSurface, "activeFocus", true);

205− } else {

206− // active focus should have gone to the parent surface

207− tryCompare(sessionContainer.session.lastSurface, "activeFocus", true);

208− }

209− }

210− }

211−

212− function test_nestedChildSessions_data() {

213− return [ { tag: "depth=2", depth: 2 },

214− { tag: "depth=8", depth: 8 }

215− ];

216− }

217−

218− function test_nestedChildSessions(data) {

219− sessionCheckbox.checked = true;

220− var sessionContainer = sessionContainerLoader.item;

221− compare(sessionContainer.childSessions.count(), 0);

222−

223− var i;

224− var sessions = [];

225− var lastSession = sessionContainer.session;

226− var delegate;

227− var container = sessionContainer;

228− for (i = 0; i < data.depth; i++) {

229− var session = ApplicationTest.addChildSession(lastSession,

230− "gallery",

231− true);

232− session.createSurface();

233− lastSession.addChildSession(session);

234− compare(container.childSessions.count(), 1);

235− sessions.push(session);

236−

237− delegate = findChild(container, "childDelegate0");

238− container = findChild(delegate, "sessionContainer");

239− lastSession = session;

240− }

241−

242− for (i = data.depth-1; i >= 0; i--) {

243− ApplicationTest.removeSession(sessions[i]);

244− }

245−

246− tryCompareFunction(function() { return sessionContainer.childSessions.count(); }, 0);

247− tryCompare(sessionSpy, "count", data.depth);

248− }

249−

250− function test_childrenAdjustForParentSize() {

251− sessionCheckbox.checked = true;

252− var sessionContainer = sessionContainerLoader.item;

253−

254− var session = ApplicationTest.addChildSession(sessionContainer.session,

255− "gallery",

256− true);

257− session.createSurface();

258− sessionContainer.session.addChildSession(session);

259−

260− var delegate = findChild(sessionContainer, "childDelegate0");

261− var childContainer = findChild(delegate, "sessionContainer");

262−

263− tryCompareFunction(function() { return childContainer.height === sessionContainer.height; }, true);

264− tryCompareFunction(function() { return childContainer.width === sessionContainer.width; }, true);

265− tryCompareFunction(function() { return childContainer.x === 0; }, true);

266− tryCompareFunction(function() { return childContainer.y === 0; }, true);

267−

268− sessionContainer.anchors.margins = units.gu(2);

269−

270− tryCompareFunction(function() { return childContainer.height === sessionContainer.height; }, true);

271− tryCompareFunction(function() { return childContainer.width === sessionContainer.width; }, true);

272− tryCompareFunction(function() { return childContainer.x === 0; }, true);

273− tryCompareFunction(function() { return childContainer.y === 0; }, true);

274− }

275−

276− function isContainerAnimating(container) {

277− var animation = findInvisibleChild(container, "sessionAnimation");

278− if (!animation) return false;

279−

280− var animating = false;

281− for (var i = 0; i < animation.transitions.length; ++i) {

282− if (animation.transitions[i].running) {

283− return true;

284− }

285− }

286− return false;

287− }

288−

289− function test_childrenAnimate() {

290− sessionCheckbox.checked = true;

291− var sessionContainer = sessionContainerLoader.item;

292−

293− var session = ApplicationTest.addChildSession(sessionContainer.session,

294− "gallery",

295− true);

296−

297− var delegate = findChild(sessionContainer, "childDelegate0");

298− var childContainer = findChild(delegate, "sessionContainer");

299−

300− // wait for animation to begin

301− tryCompareFunction(function() { return isContainerAnimating(childContainer); }, true);

302− // wait for animation to end

303− tryCompareFunction(function() { return isContainerAnimating(childContainer); }, false);

304−

305− ApplicationTest.removeSession(session);

306−

307− // wait for animation to begin

308− tryCompareFunction(function() { return isContainerAnimating(childContainer); }, true);

309− // wait for animation to end

310− tryCompareFunction(function() { return isContainerAnimating(childContainer); }, false);

311−

312− tryCompareFunction(function() { return sessionContainer.childSessions.count() }, 0);

313− }

314−

315− function test_childSessionsRemovedOnStopWhenNotLive() {

316− sessionCheckbox.checked = true;

317− var sessionContainer = sessionContainerLoader.item;

318−

319− var session = ApplicationTest.addChildSession(sessionContainer.session,

320− "gallery",

321− false);

322−

323− var delegate = findChild(sessionContainer, "childDelegate0");

324− var childContainer = findChild(delegate, "sessionContainer");

325−

326− ApplicationTest.removeSession(session);

327−

328− tryCompareFunction(function() { return sessionContainer.childSessions.count() }, 0);

329− }

330− }

331−}

tests/qmltests/Stages/tst_SurfaceContainer.qml+230−46

@@ -1,5 +1,5 @@

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

@@ -15,28 +15,40 @@

15 */

17import QtQuick 2.4

18+import QtQuick.Layouts 1.1

18import QtTest 1.0

19import QtTest 1.0

19−import Unity.Test 0.1

20+import Unity.Test 0.1 as UT

20−import ".."

21−import "../../../qml/Stages"

22import Ubuntu.Components 1.3

21import Ubuntu.Components 1.3

23import Unity.Application 0.1

22import Unity.Application 0.1

23+import "../../../qml/Stages"

25Rectangle {

26− color: "black"

26+ color: "red"

27 id: root

28− width: units.gu(70)

28+ width: units.gu(80)

29 height: units.gu(70)

31+ Connections {

32+ target: surfaceContainerLoader.status === Loader.Ready ? surfaceContainerLoader.item : null

33+ onSurfaceChanged: {

34+ surfaceCheckbox.checked = surfaceContainerLoader.item.surface !== null

35+ }

36+ }

37+

31 Component {

38 Component {

32 id: surfaceContainerComponent

39 id: surfaceContainerComponent

40+

33 SurfaceContainer {

41 SurfaceContainer {

42+ id: surfaceContainer

34 anchors.fill: parent

43 anchors.fill: parent

44+ focus: true

35 interactive: interactiveCheckbox.checked

45 interactive: interactiveCheckbox.checked

36 }

46 }

37 }

47 }

48+

38 Loader {

49 Loader {

39 id: surfaceContainerLoader

50 id: surfaceContainerLoader

51+ focus: true

40 anchors {

52 anchors {

41 top: parent.top

53 top: parent.top

42 topMargin: fullscreenCheckbox.checked ? 0 : units.gu(3)

54 topMargin: fullscreenCheckbox.checked ? 0 : units.gu(3)

@@ -56,80 +68,248 @@ Rectangle {

56 right: parent.right

68 right: parent.right

57 }

69 }

59− Column {

71+ ColumnLayout {

60 anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

72 anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

61 spacing: units.gu(1)

73 spacing: units.gu(1)

74+

75+ RowLayout {

76+ Layout.fillWidth: true

77+

62− Row {

78+ Row {

63− anchors { left: parent.left; right: parent.right }

79+ CheckBox {id: fullscreenCheckbox; checked: true; activeFocusOnPress: false }

80+ Label { text: "fullscreen" }

81+ }

82+ Row {

83+ CheckBox {id: interactiveCheckbox; checked: true; activeFocusOnPress: false }

84+ Label { text: "interactive" }

85+ }

86+ }

87+

88+ RowLayout {

89+ Layout.fillWidth: true

90+

64 CheckBox {

91 CheckBox {

65 id: surfaceCheckbox;

92 id: surfaceCheckbox;

66 checked: false;

93 checked: false;

94+ activeFocusOnPress: false

67 onCheckedChanged: {

95 onCheckedChanged: {

68 if (surfaceContainerLoader.status !== Loader.Ready)

96 if (surfaceContainerLoader.status !== Loader.Ready)

69 return;

97 return;

71 if (checked) {

99 if (checked) {

72− var fakeSurface = SurfaceManager.createSurface("fake-surface",

100+ var application = ApplicationManager.add("music-app");

73− Mir.NormalType,

101+ application.manualSurfaceCreation = true;

74− Mir.RestoredState,

102+ application.setState(ApplicationInfoInterface.Starting);

75− Qt.resolvedUrl("../Dash/artwork/music-player-design.png"));

103+

76− surfaceContainerLoader.item.surface = fakeSurface;

104+ surfaceContainerLoader.item.surface = SurfaceManager.createSurface("foo",

105+ Mir.NormalType, Mir.MaximizedState, application);

106+

107+ application.setState(ApplicationInfoInterface.Running);

77 } else {

108 } else {

109+ if (surfaceContainerLoader.item.surface) {

78− surfaceContainerLoader.item.surface.setLive(false);

110+ surfaceContainerLoader.item.surface.setLive(false);

111+ }

112+ ApplicationManager.stopApplication("music-app");

79 }

113 }

80 }

114 }

81 }

115 }

116+

117+ Label {

82− Label { text: "surface" }

118+ text: "surface"

83− }

119+ anchors.verticalCenter: parent.verticalCenter

84− Row {

120+ }

85− anchors { left: parent.left; right: parent.right }

86− CheckBox {id: fullscreenCheckbox; checked: true; }

87− Label { text: "fullscreen" }

88 }

121 }

89− Row {

122+

123+ Rectangle {

124+ border {

125+ color: "black"

126+ width: 1

127+ }

128+ anchors {

129+ left: parent.left

90− anchors { left: parent.left; right: parent.right }

130+ right: parent.right

91− CheckBox {id: interactiveCheckbox; checked: true; }

131+ }

92− Label { text: "interactive" }

132+ Layout.preferredHeight: surfaceChildrenControl.height

133+

134+ RecursingChildSessionControl {

135+ id: surfaceChildrenControl

136+ anchors { left: parent.left; right: parent.right; }

137+

138+ surface: surfaceContainerLoader.item ? surfaceContainerLoader.item.surface : null

139+ }

93 }

140 }

94− MouseTouchEmulationCheckbox {}

95 }

141 }

96 }

142 }

143

98− SignalSpy {

99− id: surfaceSpy

100− target: SurfaceManager

101− signalName: "surfaceDestroyed"

102− }

103−

104− UnityTestCase {

144+ UT.UnityTestCase {

105 id: testCase

145 id: testCase

106− name: "SurfaceContainer"

146+ name: "SessionContainer"

107− when: windowShown

108

147

109− property var surfaceContainer:

110− surfaceContainerLoader.status === Loader.Ready ? surfaceContainerLoader.item : null

148+ property Item surfaceContainer: surfaceContainerLoader.status === Loader.Ready ? surfaceContainerLoader.item : null

111

149

112 function cleanup() {

150 function cleanup() {

113 // reload our test subject to get it in a fresh state once again

151 // reload our test subject to get it in a fresh state once again

114 surfaceContainerLoader.active = false;

152 surfaceContainerLoader.active = false;

115 surfaceCheckbox.checked = false;

153 surfaceCheckbox.checked = false;

154+ interactiveCheckbox.checked = true;

116 surfaceContainerLoader.active = true;

155 surfaceContainerLoader.active = true;

117

156

118 tryCompare(surfaceContainerLoader.item, "surface", null);

157 tryCompare(surfaceContainerLoader.item, "surface", null);

119− surfaceSpy.clear();

158+ }

120

159

121− interactiveCheckbox.checked = true;

160+ when: windowShown

161+

162+ function test_addChildSession_data() {

163+ return [ { tag: "count=1", count: 1 },

164+ { tag: "count=4", count: 4 } ];

122 }

165 }

123

166

124− function test_animateRemoval() {

167+ function test_addChildSession(data) {

125 surfaceCheckbox.checked = true;

168 surfaceCheckbox.checked = true;

169+ var childSurfaces = testCase.findChild(surfaceContainer, "childSurfacesRepeater");

170+ compare(childSurfaces.count, 0);

126

171

172+ var i;

173+ for (i = 0; i < data.count; i++) {

127− verify(surfaceContainer.surface !== null);

174+ surfaceContainer.surface.createPromptSurface();

175+ compare(childSurfaces.count, i+1);

176+ }

177+

178+ for (i = data.count-1; i >= 0; i--) {

179+ {

180+ var childPromptSurface = surfaceContainer.surface.promptSurfaceList.get(i);

181+ childPromptSurface.close();

182+ }

183+ tryCompareFunction(function() { return childSurfaces.count; }, i);

184+ }

185+ }

186+

187+ function test_childSessionDestructionReturnsFocusToSiblingOrParent() {

188+ surfaceCheckbox.checked = true;

189+ var childSurfaces = testCase.findChild(surfaceContainer, "childSurfacesRepeater");

190+ compare(childSurfaces.count, 0);

191+

192+ var i;

193+ // 3 surfaces should cover all edge cases

194+ for (i = 0; i < 3; i++) {

195+ surfaceContainer.surface.createPromptSurface();

196+ compare(childSurfaces.count, i+1);

197+ }

128

198

199+ for (i = 2; i >= 0; --i) {

129− surfaceContainer.surface.setLive(false);

200+ var childPromptSurface = surfaceContainer.surface.promptSurfaceList.get(i);

201+ compare(childPromptSurface.activeFocus, true);

130

202

131− compare(surfaceContainer.state, "zombie");

203+ childPromptSurface.close();

204+ tryCompareFunction(function() { return childSurfaces.count; }, i);

205+

206+ if (i > 0) {

207+ // active focus should have gone to the yongest remaining sibling

208+ var previousSiblingSurface = surfaceContainer.surface.promptSurfaceList.get(i-1);

209+ tryCompare(previousSiblingSurface, "activeFocus", true);

210+ } else {

211+ // active focus should have gone to the parent surface

132− tryCompare(surfaceContainer, "surface", null);

212+ tryCompare(surfaceContainer.surface, "activeFocus", true);

213+ }

214+ }

215+ }

216+

217+ function test_nestedChildSessions_data() {

218+ return [ { tag: "depth=2", depth: 2 },

219+ { tag: "depth=8", depth: 8 }

220+ ];

221+ }

222+ function test_nestedChildSessions(data) {

223+ surfaceCheckbox.checked = true;

224+

225+ var i;

226+ var container = surfaceContainer;

227+ var surface = container.surface;

228+ var surfaces = [surface];

229+ var parent_childSurfaces = [null];

230+ for (i = 0; i < data.depth; i++) {

231+ surface.createPromptSurface();

232+ var childSurfaces = testCase.findChild(container, "childSurfacesRepeater");

233+ compare(childSurfaces.count, 1);

234+

235+ var childDelegate = childSurfaces.itemAt(0);

236+ container = findChild(childDelegate, "surfaceContainer");

237+ {

238+ var animationsLoader = findChild(container, "animationsLoader");

239+ tryCompare(animationsLoader, "status", Loader.Ready);

240+ waitUntilTransitionsEnd(animationsLoader.item);

241+ }

242+ surface = container.surface;

243+

244+ surfaces.push(surface);

245+ parent_childSurfaces.push(childSurfaces);

246+ }

247+

248+ for (i = surfaces.length-1; i >= 0; i--) {

249+ surfaces[i].close();

250+ if (parent_childSurfaces[i]) {

251+ tryCompareFunction(function() { return parent_childSurfaces[i].count; }, 0);

252+ }

253+ }

254+ }

255+

256+ function test_childrenAdjustForParentSize() {

257+ surfaceCheckbox.checked = true;

258+

259+ surfaceContainer.surface.createPromptSurface();

260+

261+ var delegate = findChild(surfaceContainer, "childDelegate0");

262+ var childContainer = findChild(delegate, "surfaceContainer");

263+

264+ tryCompareFunction(function() { return childContainer.height === surfaceContainer.height; }, true);

265+ tryCompareFunction(function() { return childContainer.width === surfaceContainer.width; }, true);

266+ tryCompareFunction(function() { return childContainer.x === 0; }, true);

267+ tryCompareFunction(function() { return childContainer.y === 0; }, true);

268+

269+ surfaceContainer.anchors.margins = units.gu(2);

270+

271+ tryCompareFunction(function() { return childContainer.height === surfaceContainer.height; }, true);

272+ tryCompareFunction(function() { return childContainer.width === surfaceContainer.width; }, true);

273+ tryCompareFunction(function() { return childContainer.x === 0; }, true);

274+ tryCompareFunction(function() { return childContainer.y === 0; }, true);

275+ }

276+

277+ function isContainerAnimating(container) {

278+ var animationsLoader = findChild(container, "animationsLoader");

279+ if (!animationsLoader || animationsLoader.status != Loader.Ready) {

280+ return false;

281+ }

282+

283+ var animation = animationsLoader.item;

284+

285+ var animating = false;

286+ for (var i = 0; i < animation.transitions.length; ++i) {

287+ if (animation.transitions[i].running) {

288+ return true;

289+ }

290+ }

291+ return false;

292+ }

293+

294+ function test_childrenAnimate() {

295+ surfaceCheckbox.checked = true;

296+

297+ surfaceContainer.surface.createPromptSurface();

298+

299+ var delegate = findChild(surfaceContainer, "childDelegate0");

300+ var childContainer = findChild(delegate, "surfaceContainer");

301+

302+ // wait for animation to begin

303+ tryCompareFunction(function() { return isContainerAnimating(childContainer); }, true);

304+ // wait for animation to end

305+ tryCompareFunction(function() { return isContainerAnimating(childContainer); }, false);

306+

307+ surfaceContainer.surface.promptSurfaceList.get(0).close();

308+

309+ // wait for animation to begin

310+ tryCompareFunction(function() { return isContainerAnimating(childContainer); }, true);

311+ // wait for animation to end

312+ tryCompareFunction(function() { return isContainerAnimating(childContainer); }, false);

133 }

313 }

134

314

135 function test_surfaceItemGetsNoTouchesWhenContainerNotInteractive() {

315 function test_surfaceItemGetsNoTouchesWhenContainerNotInteractive() {

@@ -142,14 +322,14 @@ Rectangle {

142 surfaceItem.touchPressCount = 0;

322 surfaceItem.touchPressCount = 0;

143 surfaceItem.touchReleaseCount = 0;

323 surfaceItem.touchReleaseCount = 0;

144

324

145− tap(surfaceContainer, surfaceContainer.width / 2, surfaceContainer.height / 2);

325+ tap(surfaceContainer);

146

326

147 // surface got touches as the surfaceContainer is interactive

327 // surface got touches as the surfaceContainer is interactive

148 compare(surfaceItem.touchPressCount, 1)

328 compare(surfaceItem.touchPressCount, 1)

149 compare(surfaceItem.touchReleaseCount, 1);

329 compare(surfaceItem.touchReleaseCount, 1);

150

330

151 interactiveCheckbox.checked = false;

331 interactiveCheckbox.checked = false;

152− tap(surfaceContainer, surfaceContainer.width / 2, surfaceContainer.height / 2);

332+ tap(surfaceContainer);

153

333

154 // surface shouldn't get the touches from the second tap as the surfaceContainer

334 // surface shouldn't get the touches from the second tap as the surfaceContainer

155 // was *not* interactive when it happened.

335 // was *not* interactive when it happened.

@@ -164,6 +344,8 @@ Rectangle {

164 var surfaceItem = findChild(surfaceContainer, "surfaceItem");

344 var surfaceItem = findChild(surfaceContainer, "surfaceItem");

165 verify(surfaceItem !== null);

345 verify(surfaceItem !== null);

166

346

347+ surfaceContainer.focus = false;

348+

167 compare(surfaceItem.activeFocus, false);

349 compare(surfaceItem.activeFocus, false);

168 mouseClick(surfaceContainer);

350 mouseClick(surfaceContainer);

169 compare(surfaceItem.activeFocus, true);

351 compare(surfaceItem.activeFocus, true);

@@ -176,6 +358,8 @@ Rectangle {

176 var surfaceItem = findChild(surfaceContainer, "surfaceItem");

358 var surfaceItem = findChild(surfaceContainer, "surfaceItem");

177 verify(surfaceItem !== null);

359 verify(surfaceItem !== null);

178

360

361+ surfaceContainer.focus = false;

362+

179 compare(surfaceItem.activeFocus, false);

363 compare(surfaceItem.activeFocus, false);

180 tap(surfaceContainer);

364 tap(surfaceContainer);

181 compare(surfaceItem.activeFocus, true);

365 compare(surfaceItem.activeFocus, true);

tests/qmltests/Stages/tst_TabletStage.qml+250−84

@@ -1,5 +1,5 @@

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

@@ -34,6 +34,11 @@ Rectangle {

35 property var greeter: { fullyShown: true }

37+ TopLevelSurfaceList {

38+ id: topSurfaceList

39+ applicationsModel: ApplicationManager

40+ }

41+

37 Loader {

42 Loader {

38 id: tabletStageLoader

43 id: tabletStageLoader

@@ -62,6 +67,8 @@ Rectangle {

62 primary: Qt.LandscapeOrientation

67 primary: Qt.LandscapeOrientation

63 }

68 }

64 focus: true

69 focus: true

70+ applicationManager: ApplicationManager

71+ topLevelSurfaceList: topSurfaceList

65 }

72 }

66 }

73 }

67 }

74 }

@@ -76,6 +83,9 @@ Rectangle {

76 right: parent.right

83 right: parent.right

77 }

84 }

86+ // don't let mouse clicks in the controls area disturb the TabletStage behind it

87+ MouseArea { anchors.fill: parent }

88+

79 Column {

89 Column {

80 anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

90 anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }

81 spacing: units.gu(1)

91 spacing: units.gu(1)

@@ -130,18 +140,21 @@ Rectangle {

130 tabletStageLoader.active = true;

140 tabletStageLoader.active = true;

131 tryCompare(tabletStageLoader, "status", Loader.Ready);

141 tryCompare(tabletStageLoader, "status", Loader.Ready);

132

142

143+ tryCompare(topSurfaceList, "count", 1);

144+ compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

145+

133 // this is very strange, but sometimes the test starts without

146 // this is very strange, but sometimes the test starts without

134 // TabletStage components having finished loading themselves

147 // TabletStage components having finished loading themselves

135− var appWindow = null;

148+ var appWindow = null

136 while (!appWindow) {

149 while (!appWindow) {

137− appWindow = findChild(tabletStage, "appWindow_unity8-dash");

150+ appWindow = findAppWindowForSurfaceId(topSurfaceList.idAt(0));

138 if (!appWindow) {

151 if (!appWindow) {

139− console.log("didn't find appWindow_unity8-dash in " + tabletStage + ". Trying again...");

152+ console.log("didn't find unity8-dash appWindow in " + tabletStage + ". Trying again...");

140 wait(50);

153 wait(50);

141 }

154 }

142 }

155 }

143

156

144− waitUntilAppSurfaceShowsUp("unity8-dash");

157+ waitUntilAppSurfaceShowsUp(topSurfaceList.idAt(0));

145 sideStage.hideNow()

158 sideStage.hideNow()

146 }

159 }

147

160

@@ -165,34 +178,35 @@ Rectangle {

165 WindowStateStorage.clear();

178 WindowStateStorage.clear();

166 }

179 }

167

180

168− function waitUntilAppSurfaceShowsUp(appId) {

181+ function waitUntilAppSurfaceShowsUp(surfaceId) {

169− var appWindow = findChild(tabletStage, "appWindow_" + appId);

182+ var appWindow = findAppWindowForSurfaceId(surfaceId);

170 verify(appWindow);

183 verify(appWindow);

171 var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

184 var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

172 verify(appWindowStates);

185 verify(appWindowStates);

173 tryCompare(appWindowStates, "state", "surface");

186 tryCompare(appWindowStates, "state", "surface");

174 }

187 }

175

188

176− function switchToApp(targetAppId) {

189+ function findAppWindowForSurfaceId(surfaceId) {

177− touchFlick(tabletStage,

190+ var spreadDelegate = findChild(tabletStage, "spreadDelegate_" + surfaceId);

178− tabletStage.width - (tabletStage.dragAreaWidth / 2), tabletStage.height / 2,

191+ if (!spreadDelegate) {

179− tabletStage.x + 1, tabletStage.height / 2);

192+ return null;

180−

193+ }

181− var spreadView = findChild(tabletStage, "spreadView");

194+ var appWindow = findChild(spreadDelegate, "appWindow");

182− verify(spreadView);

195+ return appWindow;

183− tryCompare(spreadView, "phase", 2);

196+ }

184− tryCompare(spreadView, "flicking", false);

185− tryCompare(spreadView, "moving", false);

186

197

187− waitUntilAppDelegateStopsMoving(targetAppId);

198+ function switchToSurface(targetSurfaceId) {

199+ performEdgeSwipeToShowAppSpread();

188

200

189− var targetAppWindow = findChild(tabletStage, "appWindow_" + targetAppId);

201+ waitUntilAppDelegateStopsMoving(targetSurfaceId);

202+ var targetAppWindow = findAppWindowForSurfaceId(targetSurfaceId);

203+ verify(targetAppWindow);

190 tap(targetAppWindow, 10, 10);

204 tap(targetAppWindow, 10, 10);

191 }

205 }

192

206

193− function waitUntilAppDelegateStopsMoving(targetAppId)

207+ function waitUntilAppDelegateStopsMoving(targetSurfaceId)

194 {

208 {

195− var targetAppDelegate = findChild(tabletStage, "tabletSpreadDelegate_" + targetAppId);

209+ var targetAppDelegate = findChild(tabletStage, "spreadDelegate_" + targetSurfaceId);

196 verify(targetAppDelegate);

210 verify(targetAppDelegate);

197 var lastValue = undefined;

211 var lastValue = undefined;

198 do {

212 do {

@@ -201,56 +215,86 @@ Rectangle {

201 } while (lastValue != targetAppDelegate.animatedProgress);

215 } while (lastValue != targetAppDelegate.animatedProgress);

202 }

216 }

203

217

218+ function performEdgeSwipeToShowAppSpread() {

219+ touchFlick(tabletStage,

220+ tabletStage.width - (tabletStage.dragAreaWidth / 2), tabletStage.height / 2,

221+ tabletStage.x + 1, tabletStage.height / 2);

222+

223+ var spreadView = findChild(tabletStage, "spreadView");

224+ verify(spreadView);

225+ tryCompare(spreadView, "phase", 2);

226+ tryCompare(spreadView, "flicking", false);

227+ tryCompare(spreadView, "moving", false);

228+ }

229+

230+ function swipeSurfaceUpwards(surfaceId) {

231+ var appWindow = findAppWindowForSurfaceId(surfaceId);

232+ verify(appWindow);

233+

234+ // Swipe from the left side of the surface as it's the one most likely

235+ // to not be covered by other surfaces when they're all being shown in the spread

236+ touchFlick(appWindow,

237+ appWindow.width * 0.1, appWindow.height / 2,

238+ appWindow.width * 0.1, -appWindow.height / 2);

239+ }

240+

204 function test_tappingSwitchesFocusBetweenStages() {

241 function test_tappingSwitchesFocusBetweenStages() {

205 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

242 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

206

243

244+ var webbrowserSurfaceId = topSurfaceList.nextId;

207 webbrowserCheckBox.checked = true;

245 webbrowserCheckBox.checked = true;

208− waitUntilAppSurfaceShowsUp(webbrowserCheckBox.appId);

246+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

209 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

247 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

210 compare(webbrowserApp.stage, ApplicationInfoInterface.MainStage);

248 compare(webbrowserApp.stage, ApplicationInfoInterface.MainStage);

249+ var webbrowserWindow = findAppWindowForSurfaceId(webbrowserSurfaceId);

250+ verify(webbrowserWindow);

251+

211− tryCompare(webbrowserApp.session.lastSurface, "activeFocus", true);

252+ tryCompare(webbrowserWindow.surface, "activeFocus", true);

212

253

254+ var dialerSurfaceId = topSurfaceList.nextId;

213 dialerCheckBox.checked = true;

255 dialerCheckBox.checked = true;

214− waitUntilAppSurfaceShowsUp(dialerCheckBox.appId);

256+ waitUntilAppSurfaceShowsUp(dialerSurfaceId);

257+

215 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

258 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

259+ var dialerDelegate = findChild(tabletStage, "spreadDelegate_" + dialerSurfaceId);

260+ verify(dialerDelegate);

216− compare(dialerApp.stage, ApplicationInfoInterface.SideStage);

261+ compare(dialerDelegate.stage, ApplicationInfoInterface.SideStage);

262+

217− tryCompare(dialerApp.session.lastSurface, "activeFocus", true);

263+ tryCompare(dialerDelegate.surface, "activeFocus", true);

218− tryCompare(webbrowserApp.session.lastSurface, "activeFocus", false);

264+ tryCompare(webbrowserWindow.surface, "activeFocus", false);

219

265

220 // Tap on the main stage application and check if the focus

266 // Tap on the main stage application and check if the focus

221 // has been passed to it.

267 // has been passed to it.

222

268

223− var webbrowserWindow = findChild(tabletStage, "appWindow_" + webbrowserApp.appId);

224− verify(webbrowserWindow);

225 tap(webbrowserWindow);

269 tap(webbrowserWindow);

226

270

227− tryCompare(dialerApp.session.lastSurface, "activeFocus", false);

271+ tryCompare(dialerDelegate.surface, "activeFocus", false);

228− tryCompare(webbrowserApp.session.lastSurface, "activeFocus", true);

272+ tryCompare(webbrowserWindow.surface, "activeFocus", true);

229

273

230 // Now tap on the side stage application and check if the focus

274 // Now tap on the side stage application and check if the focus

231 // has been passed back to it.

275 // has been passed back to it.

232

276

233− var dialerWindow = findChild(tabletStage, "appWindow_" + dialerApp.appId);

277+ tap(dialerDelegate);

234− verify(dialerWindow);

235− tap(dialerWindow);

236

278

237− tryCompare(dialerApp.session.lastSurface, "activeFocus", true);

279+ tryCompare(dialerDelegate.surface, "activeFocus", true);

238− tryCompare(webbrowserApp.session.lastSurface, "activeFocus", false);

280+ tryCompare(webbrowserWindow.surface, "activeFocus", false);

239 }

281 }

240

282

241 function test_closeAppInSideStage() {

283 function test_closeAppInSideStage() {

242 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

284 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

243

285

286+ var dialerSurfaceId = topSurfaceList.nextId;

244 dialerCheckBox.checked = true;

287 dialerCheckBox.checked = true;

245− waitUntilAppSurfaceShowsUp(dialerCheckBox.appId);

288+ waitUntilAppSurfaceShowsUp(dialerSurfaceId);

246

289

247 performEdgeSwipeToShowAppSpread();

290 performEdgeSwipeToShowAppSpread();

248

291

249− var appDelegate = findChild(tabletStage, "tabletSpreadDelegate_" + dialerCheckBox.appId);

292+ var appDelegate = findChild(tabletStage, "spreadDelegate_" + dialerSurfaceId);

250 verify(appDelegate);

293 verify(appDelegate);

294+ compare(appDelegate.stage, ApplicationInfoInterface.SideStage);

251 tryCompare(appDelegate, "swipeToCloseEnabled", true);

295 tryCompare(appDelegate, "swipeToCloseEnabled", true);

252

296

253− swipeAppUpwards(dialerCheckBox.appId);

297+ swipeSurfaceUpwards(dialerSurfaceId);

254

298

255 // Check that dialer-app has been closed

299 // Check that dialer-app has been closed

256

300

@@ -263,54 +307,37 @@ Rectangle {

263 }, null);

307 }, null);

264 }

308 }

265

309

266− function performEdgeSwipeToShowAppSpread() {

267− var touchStartY = tabletStage.height / 2;

268− touchFlick(tabletStage,

269− tabletStage.width - 1, touchStartY,

270− 0, touchStartY);

271−

272− var spreadView = findChild(tabletStage, "spreadView");

273− verify(spreadView);

274− tryCompare(spreadView, "phase", 2);

275− tryCompare(spreadView, "flicking", false);

276− tryCompare(spreadView, "moving", false);

277− }

278−

279− function swipeAppUpwards(appId) {

280− var appWindow = findChild(tabletStage, "appWindow_" + appId);

281− verify(appWindow);

282−

283− touchFlick(appWindow,

284− appWindow.width / 2, appWindow.height / 2,

285− appWindow.width / 2, -appWindow.height / 2);

286− }

287−

288 function test_suspendsAndResumesAppsInMainStage() {

310 function test_suspendsAndResumesAppsInMainStage() {

311+ var webbrowserSurfaceId = topSurfaceList.nextId;

289 webbrowserCheckBox.checked = true;

312 webbrowserCheckBox.checked = true;

313+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

290 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

314 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

315+ var webbrowserDelegate = findChild(tabletStage, "spreadDelegate_" + webbrowserSurfaceId);

291− compare(webbrowserApp.stage, ApplicationInfoInterface.MainStage);

316+ compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

292

317

293 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

318 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

294

319

320+ var gallerySurfaceId = topSurfaceList.nextId;

295 galleryCheckBox.checked = true;

321 galleryCheckBox.checked = true;

322+ waitUntilAppSurfaceShowsUp(gallerySurfaceId);

296 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

323 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

324+ var galleryDelegate = findChild(tabletStage, "spreadDelegate_" + gallerySurfaceId);

297− compare(galleryApp.stage, ApplicationInfoInterface.MainStage);

325+ compare(galleryDelegate.stage, ApplicationInfoInterface.MainStage);

298

326

299 tryCompare(galleryApp, "state", ApplicationInfoInterface.Running);

327 tryCompare(galleryApp, "state", ApplicationInfoInterface.Running);

300 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

328 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

301

329

302− switchToApp(webbrowserApp.appId);

330+ switchToSurface(webbrowserSurfaceId);

303

331

304 tryCompare(galleryApp, "state", ApplicationInfoInterface.Suspended);

332 tryCompare(galleryApp, "state", ApplicationInfoInterface.Suspended);

305 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

333 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

306

334

307− switchToApp(galleryApp.appId);

335+ switchToSurface(gallerySurfaceId);

308

336

309 tryCompare(galleryApp, "state", ApplicationInfoInterface.Running);

337 tryCompare(galleryApp, "state", ApplicationInfoInterface.Running);

310 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

338 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

311 }

339 }

312

340

313−

314 function test_foregroundMainAndSideStageAppsAreKeptRunning() {

341 function test_foregroundMainAndSideStageAppsAreKeptRunning() {

315 WindowStateStorage.saveStage(facebookCheckBox.appId, ApplicationInfoInterface.SideStage)

342 WindowStateStorage.saveStage(facebookCheckBox.appId, ApplicationInfoInterface.SideStage)

316 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

343 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

@@ -321,30 +348,37 @@ Rectangle {

321 // launch two main stage apps

348 // launch two main stage apps

322 // gallery will be on foreground and webbrowser on background

349 // gallery will be on foreground and webbrowser on background

323

350

351+ var webbrowserSurfaceId = topSurfaceList.nextId;

324 webbrowserCheckBox.checked = true;

352 webbrowserCheckBox.checked = true;

325− waitUntilAppSurfaceShowsUp(webbrowserCheckBox.appId)

353+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

326 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

354 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

327 compare(webbrowserApp.stage, ApplicationInfoInterface.MainStage);

355 compare(webbrowserApp.stage, ApplicationInfoInterface.MainStage);

328

356

357+ var gallerySurfaceId = topSurfaceList.nextId;

329 galleryCheckBox.checked = true;

358 galleryCheckBox.checked = true;

330− waitUntilAppSurfaceShowsUp(galleryCheckBox.appId)

359+ waitUntilAppSurfaceShowsUp(gallerySurfaceId);

331 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

360 var galleryApp = ApplicationManager.findApplication(galleryCheckBox.appId);

361+ var galleryDelegate = findChild(tabletStage, "spreadDelegate_" + gallerySurfaceId);

332− compare(galleryApp.stage, ApplicationInfoInterface.MainStage);

362+ compare(galleryDelegate.stage, ApplicationInfoInterface.MainStage);

333

363

334 compare(stagesPriv.mainStageAppId, galleryCheckBox.appId);

364 compare(stagesPriv.mainStageAppId, galleryCheckBox.appId);

335

365

336 // then launch two side stage apps

366 // then launch two side stage apps

337 // facebook will be on foreground and dialer on background

367 // facebook will be on foreground and dialer on background

338

368

369+ var dialerSurfaceId = topSurfaceList.nextId;

339 dialerCheckBox.checked = true;

370 dialerCheckBox.checked = true;

340− waitUntilAppSurfaceShowsUp(dialerCheckBox.appId)

371+ waitUntilAppSurfaceShowsUp(dialerSurfaceId);

341 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

372 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

373+ var dialerDelegate = findChild(tabletStage, "spreadDelegate_" + dialerSurfaceId);

342− compare(dialerApp.stage, ApplicationInfoInterface.SideStage);

374+ compare(dialerDelegate.stage, ApplicationInfoInterface.SideStage);

343

375

376+ var facebookSurfaceId = topSurfaceList.nextId;

344 facebookCheckBox.checked = true;

377 facebookCheckBox.checked = true;

345− waitUntilAppSurfaceShowsUp(facebookCheckBox.appId)

378+ waitUntilAppSurfaceShowsUp(facebookSurfaceId);

346 var facebookApp = ApplicationManager.findApplication(facebookCheckBox.appId);

379 var facebookApp = ApplicationManager.findApplication(facebookCheckBox.appId);

380+ var facebookDelegate = findChild(tabletStage, "spreadDelegate_" + facebookSurfaceId);

347− compare(facebookApp.stage, ApplicationInfoInterface.SideStage);

381+ compare(facebookDelegate.stage, ApplicationInfoInterface.SideStage);

348

382

349 compare(stagesPriv.sideStageAppId, facebookCheckBox.appId);

383 compare(stagesPriv.sideStageAppId, facebookCheckBox.appId);

350

384

@@ -356,14 +390,14 @@ Rectangle {

356 tryCompare(facebookApp, "state", ApplicationInfoInterface.Running);

390 tryCompare(facebookApp, "state", ApplicationInfoInterface.Running);

357 tryCompare(dialerApp, "state", ApplicationInfoInterface.Suspended);

391 tryCompare(dialerApp, "state", ApplicationInfoInterface.Suspended);

358

392

359− switchToApp(dialerCheckBox.appId);

393+ switchToSurface(dialerSurfaceId);

360

394

361 tryCompare(galleryApp, "state", ApplicationInfoInterface.Running);

395 tryCompare(galleryApp, "state", ApplicationInfoInterface.Running);

362 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

396 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

363 tryCompare(facebookApp, "state", ApplicationInfoInterface.Suspended);

397 tryCompare(facebookApp, "state", ApplicationInfoInterface.Suspended);

364 tryCompare(dialerApp, "state", ApplicationInfoInterface.Running);

398 tryCompare(dialerApp, "state", ApplicationInfoInterface.Running);

365

399

366− switchToApp(webbrowserCheckBox.appId);

400+ switchToSurface(webbrowserSurfaceId);

367

401

368 tryCompare(galleryApp, "state", ApplicationInfoInterface.Suspended);

402 tryCompare(galleryApp, "state", ApplicationInfoInterface.Suspended);

369 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

403 tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

@@ -374,15 +408,19 @@ Rectangle {

374 function test_foregroundAppsAreSuspendedWhenStageIsSuspended() {

408 function test_foregroundAppsAreSuspendedWhenStageIsSuspended() {

375 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

409 WindowStateStorage.saveStage(dialerCheckBox.appId, ApplicationInfoInterface.SideStage)

376

410

411+ var webbrowserSurfaceId = topSurfaceList.nextId;

377 webbrowserCheckBox.checked = true;

412 webbrowserCheckBox.checked = true;

378− waitUntilAppSurfaceShowsUp(webbrowserCheckBox.appId)

413+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

379 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

414 var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

415+ var webbrowserDelegate = findChild(tabletStage, "spreadDelegate_" + webbrowserSurfaceId);

380− compare(webbrowserApp.stage, ApplicationInfoInterface.MainStage);

416+ compare(webbrowserDelegate.stage, ApplicationInfoInterface.MainStage);

381

417

418+ var dialerSurfaceId = topSurfaceList.nextId;

382 dialerCheckBox.checked = true;

419 dialerCheckBox.checked = true;

383− waitUntilAppSurfaceShowsUp(dialerCheckBox.appId)

420+ waitUntilAppSurfaceShowsUp(dialerSurfaceId);

384 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

421 var dialerApp = ApplicationManager.findApplication(dialerCheckBox.appId);

422+ var dialerDelegate = findChild(tabletStage, "spreadDelegate_" + dialerSurfaceId);

385− compare(dialerApp.stage, ApplicationInfoInterface.SideStage);

423+ compare(dialerDelegate.stage, ApplicationInfoInterface.SideStage);

386

424

387

425

388 compare(webbrowserApp.requestedState, ApplicationInfoInterface.RequestedRunning);

426 compare(webbrowserApp.requestedState, ApplicationInfoInterface.RequestedRunning);

@@ -467,8 +505,9 @@ Rectangle {

467 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

505 tryCompare(stagesPriv, "mainStageAppId", "unity8-dash");

468 tryCompare(stagesPriv, "sideStageAppId", "");

506 tryCompare(stagesPriv, "sideStageAppId", "");

469

507

508+ var webbrowserSurfaceId = topSurfaceList.nextId;

470 webbrowserCheckBox.checked = true;

509 webbrowserCheckBox.checked = true;

471− waitUntilAppSurfaceShowsUp(webbrowserCheckBox.appId)

510+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

472

511

473 tryCompare(stagesPriv, "mainStageAppId", data.mainStageAppId);

512 tryCompare(stagesPriv, "mainStageAppId", data.mainStageAppId);

474 tryCompare(stagesPriv, "sideStageAppId", data.sideStageAppId);

513 tryCompare(stagesPriv, "sideStageAppId", data.sideStageAppId);

@@ -476,10 +515,11 @@ Rectangle {

476

515

477 function test_loadSideStageByDragginFromMainStage() {

516 function test_loadSideStageByDragginFromMainStage() {

478 sideStage.showNow();

517 sideStage.showNow();

518+ var webbrowserSurfaceId = topSurfaceList.nextId;

479 webbrowserCheckBox.checked = true;

519 webbrowserCheckBox.checked = true;

480− waitUntilAppSurfaceShowsUp(webbrowserCheckBox.appId);

520+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

481

521

482− var appDelegate = findChild(tabletStage, "tabletSpreadDelegate_" + webbrowserCheckBox.appId);

522+ var appDelegate = findChild(tabletStage, "spreadDelegate_" + webbrowserSurfaceId);

483 verify(appDelegate);

523 verify(appDelegate);

484 compare(appDelegate.stage, ApplicationInfoInterface.MainStage);

524 compare(appDelegate.stage, ApplicationInfoInterface.MainStage);

485

525

@@ -504,10 +544,11 @@ Rectangle {

504 function test_unloadSideStageByDragginFromStageStage() {

544 function test_unloadSideStageByDragginFromStageStage() {

505 sideStage.showNow();

545 sideStage.showNow();

506 WindowStateStorage.saveStage(webbrowserCheckBox.appId, ApplicationInfoInterface.SideStage)

546 WindowStateStorage.saveStage(webbrowserCheckBox.appId, ApplicationInfoInterface.SideStage)

547+ var webbrowserSurfaceId = topSurfaceList.nextId;

507 webbrowserCheckBox.checked = true;

548 webbrowserCheckBox.checked = true;

508− waitUntilAppSurfaceShowsUp(webbrowserCheckBox.appId);

549+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

509

550

510− var appDelegate = findChild(tabletStage, "tabletSpreadDelegate_" + webbrowserCheckBox.appId);

551+ var appDelegate = findChild(tabletStage, "spreadDelegate_" + webbrowserSurfaceId);

511 verify(appDelegate);

552 verify(appDelegate);

512 compare(appDelegate.stage, ApplicationInfoInterface.SideStage);

553 compare(appDelegate.stage, ApplicationInfoInterface.SideStage);

513

554

@@ -527,5 +568,130 @@ Rectangle {

527

568

528 tryCompare(appDelegate, "stage", ApplicationInfoInterface.MainStage);

569 tryCompare(appDelegate, "stage", ApplicationInfoInterface.MainStage);

529 }

570 }

571+

572+ function test_closeSurfaceOfMultiSurfaceApp() {

573+ var surface1Id = topSurfaceList.nextId;

574+ webbrowserCheckBox.checked = true;

575+ waitUntilAppSurfaceShowsUp(surface1Id);

576+ var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

577+

578+ var surface2Id = topSurfaceList.nextId;

579+ verify(surface1Id !== surface2Id); // sanity checking

580+ webbrowserCheckBox.createSurface();

581+ waitUntilAppSurfaceShowsUp(surface2Id);

582+

583+ performEdgeSwipeToShowAppSpread();

584+

585+ var appDelegate = findChild(tabletStage, "spreadDelegate_" + surface1Id);

586+ verify(appDelegate);

587+ tryCompare(appDelegate, "swipeToCloseEnabled", true);

588+

589+ compare(webbrowserApp.surfaceList.count, 2);

590+ compare(webbrowserApp.state, ApplicationInfoInterface.Running);

591+

592+ swipeSurfaceUpwards(surface1Id);

593+

594+ // Surface must eventually be gone

595+ tryCompareFunction(function() { return topSurfaceList.indexForId(surface1Id); }, -1);

596+ tryCompare(webbrowserApp.surfaceList, "count", 1);

597+ compare(webbrowserApp.state, ApplicationInfoInterface.Running);

598+ }

599+

600+ /*

601+ 1- Suspended app gets killed behind the scenes, causing its surface to go zombie.

602+ 2- Surface gets screenshotted and removed. Its slot in the topSurfaceList remains,

603+ though (so ApplicationWindow can display the screenshot in its place).

604+ 3- User taps on the screenshot of the long-gone surface.

605+

606+ Expected outcome:

607+ Application gets relaunched. Its new surface will seamlessly replace the screenshot.

608+ */

609+ function test_selectSuspendedAppWithoutSurface() {

610+ compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

611+ var dashSurfaceId = topSurfaceList.idAt(0);

612+ var dashSurface = topSurfaceList.surfaceAt(0);

613+

614+ var webbrowserSurfaceId = topSurfaceList.nextId;

615+ webbrowserCheckBox.checked = true;

616+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

617+ var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

618+

619+ switchToSurface(dashSurfaceId);

620+

621+ tryCompare(MirFocusController, "focusedSurface", dashSurface);

622+ tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

623+

624+ compare(webbrowserApp.surfaceList.count, 1);

625+

626+ // simulate the suspended app being killed by the out-of-memory daemon

627+ webbrowserApp.surfaceList.get(0).setLive(false);

628+

629+ // wait until the surface is gone

630+ tryCompare(webbrowserApp.surfaceList, "count", 0);

631+ compare(topSurfaceList.surfaceAt(topSurfaceList.indexForId(webbrowserSurfaceId)), null);

632+

633+ switchToSurface(webbrowserSurfaceId);

634+

635+ // webbrowser should have been brought to front

636+ tryCompareFunction(function(){return topSurfaceList.idAt(0);}, webbrowserSurfaceId);

637+

638+ // and it should eventually get a new surface and get resumed

639+ tryCompareFunction(function(){return topSurfaceList.surfaceAt(0) !== null;}, true);

640+ compare(topSurfaceList.count, 2); // still two top-level items

641+ tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Running);

642+ compare(webbrowserApp.surfaceList.count, 1);

643+ }

644+

645+ /*

646+ 1 - user suspends an application (ie, focus a surface from a different application)

647+ 2 - That suspended application gets killed, causing its surface to go zombie

648+ 3 - user goes to spread and closes that zombie surface. Actually, by that time

649+ Tablet shell will be displaying a screenshot of it instead, so there's no

650+ MirSurface whatsoever backing it up.

651+ */

652+ function test_closeZombieSurface()

653+ {

654+ compare(topSurfaceList.applicationAt(0).appId, "unity8-dash");

655+ var dashSurfaceId = topSurfaceList.idAt(0);

656+ var dashSurface = topSurfaceList.surfaceAt(0);

657+

658+ var webbrowserSurfaceId = topSurfaceList.nextId;

659+ webbrowserCheckBox.checked = true;

660+ waitUntilAppSurfaceShowsUp(webbrowserSurfaceId);

661+ var webbrowserApp = ApplicationManager.findApplication(webbrowserCheckBox.appId);

662+

663+ switchToSurface(dashSurfaceId);

664+

665+ tryCompare(MirFocusController, "focusedSurface", dashSurface);

666+ tryCompare(webbrowserApp, "state", ApplicationInfoInterface.Suspended);

667+

668+ compare(webbrowserApp.surfaceList.count, 1);

669+

670+ // simulate the suspended app being killed by the out-of-memory daemon

671+ webbrowserApp.surfaceList.get(0).setLive(false);

672+

673+ // wait until the surface is gone

674+ tryCompare(webbrowserApp.surfaceList, "count", 0);

675+ compare(topSurfaceList.surfaceAt(topSurfaceList.indexForId(webbrowserSurfaceId)), null);

676+

677+ performEdgeSwipeToShowAppSpread();

678+

679+ {

680+ var appDelegate = findChild(tabletStage, "spreadDelegate_" + webbrowserSurfaceId);

681+ verify(appDelegate);

682+ tryCompare(appDelegate, "swipeToCloseEnabled", true);

683+ }

684+

685+ swipeSurfaceUpwards(webbrowserSurfaceId);

686+

687+ // webbrowser entry is nowhere to be seen

688+ tryCompareFunction(function(){return topSurfaceList.indexForId(webbrowserSurfaceId);}, -1);

689+

690+ // nor is its app

691+ compare(ApplicationManager.findApplication(webbrowserCheckBox.appId), null);

692+

693+ // only unity8-dash surface is left

694+ compare(topSurfaceList.count, 1);

695+ }

530 }

696 }

531}

697}

tests/qmltests/Tutorial/tst_Tutorial.qml−8

@@ -280,14 +280,6 @@ Rectangle {

280 prepareShell();

281 }

282

283− function killApps() {

284− while (ApplicationManager.count > 1) {

285− var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0

286− ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);

287− }

288− compare(ApplicationManager.count, 1)

289− }

290−

291 function swipeAwayGreeter() {

283 function swipeAwayGreeter() {

292 var coverPage = findChild(shell, "coverPage");

284 var coverPage = findChild(shell, "coverPage");

293 tryCompare(coverPage, "showProgress", 1);

285 tryCompare(coverPage, "showProgress", 1);

tests/qmltests/tst_OrientedShell.qml+76−55

@@ -24,6 +24,7 @@ import Unity.Test 0.1

24import IntegratedLightDM 0.1 as LightDM

25import Powerd 0.1

26import Unity.InputInfo 0.1

27+import Utils 0.1

28import "../../qml"

29import "../../qml"

@@ -434,6 +435,7 @@ Rectangle {

434

435

435 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

436 property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null

436 property Item shell

437 property Item shell

438+ property QtObject topLevelSurfaceList

437

439

438 SignalSpy { id: signalSpy }

440 SignalSpy { id: signalSpy }

439 SignalSpy { id: signalSpy2 }

441 SignalSpy { id: signalSpy2 }

@@ -485,6 +487,7 @@ Rectangle {

485 function cleanup() {

487 function cleanup() {

486 tryCompare(shell, "enabled", true); // make sure greeter didn't leave us in disabled state

488 tryCompare(shell, "enabled", true); // make sure greeter didn't leave us in disabled state

487 shell = null;

489 shell = null;

490+ topLevelSurfaceList = null;

488

491

489 tearDown();

492 tearDown();

490 }

493 }

@@ -533,17 +536,20 @@ Rectangle {

533 function test_appSupportingOnlyPrimaryOrientationWillOnlyRotateInLandscape(data) {

536 function test_appSupportingOnlyPrimaryOrientationWillOnlyRotateInLandscape(data) {

534 loadShell(data.deviceName);

537 loadShell(data.deviceName);

535

538

539+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

540+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

541+ var dashAppWindow = findAppWindowForSurfaceId(dashSurfaceId);

542+

536 // unity8-dash supports only primary orientation and should be already running

543 // unity8-dash supports only primary orientation and should be already running

537− var dashAppWindow = findChild(shell, "appWindow_unity8-dash");

544+

538− verify(dashAppWindow);

539 compare(ApplicationManager.focusedApplicationId, "unity8-dash");

545 compare(ApplicationManager.focusedApplicationId, "unity8-dash");

540− var dashApp = dashAppWindow.application

546+ var dashApp = dashAppWindow.application;

541 verify(dashApp);

547 verify(dashApp);

542 compare(dashApp.rotatesWindowContents, false);

548 compare(dashApp.rotatesWindowContents, false);

543 compare(dashApp.supportedOrientations, Qt.PrimaryOrientation);

549 compare(dashApp.supportedOrientations, Qt.PrimaryOrientation);

544 compare(dashApp.stage, ApplicationInfoInterface.MainStage);

550 compare(dashApp.stage, ApplicationInfoInterface.MainStage);

545

551

546− tryCompareFunction(function(){return dashApp.session.lastSurface != null;}, true);

552+ tryCompareFunction(function(){return dashApp.surfaceList.count > 0;}, true);

547 verify(checkAppSurfaceOrientation(dashAppWindow, dashApp, root.primaryOrientationAngle));

553 verify(checkAppSurfaceOrientation(dashAppWindow, dashApp, root.primaryOrientationAngle));

548

554

549 compare(shell.transformRotationAngle, root.primaryOrientationAngle);

555 compare(shell.transformRotationAngle, root.primaryOrientationAngle);

@@ -610,6 +616,7 @@ Rectangle {

610 }

616 }

611 function test_appRotatesWindowContents(data) {

617 function test_appRotatesWindowContents(data) {

612 loadShell(data.deviceName);

618 loadShell(data.deviceName);

619+ var cameraSurfaceId = topLevelSurfaceList.nextId;

613 var cameraApp = ApplicationManager.startApplication("camera-app");

620 var cameraApp = ApplicationManager.startApplication("camera-app");

614 verify(cameraApp);

621 verify(cameraApp);

615

622

@@ -619,9 +626,9 @@ Rectangle {

619 compare(cameraApp.supportedOrientations, Qt.PortraitOrientation | Qt.LandscapeOrientation

626 compare(cameraApp.supportedOrientations, Qt.PortraitOrientation | Qt.LandscapeOrientation

620 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

627 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

621

628

622− waitUntilAppSurfaceShowsUp("camera-app")

629+ waitUntilAppWindowIsFullyLoaded(cameraSurfaceId);

623

630

624− var cameraSurface = cameraApp.session.lastSurface;

631+ var cameraSurface = cameraApp.surfaceList.get(0);

625 verify(cameraSurface);

632 verify(cameraSurface);

626

633

627 var focusChangedSpy = signalSpy;

634 var focusChangedSpy = signalSpy;

@@ -687,6 +694,7 @@ Rectangle {

687 }

694 }

688 function test_switchingToAppWithDifferentRotation(data) {

695 function test_switchingToAppWithDifferentRotation(data) {

689 loadShell(data.deviceName);

696 loadShell(data.deviceName);

697+ var gmailSurfaceId = topLevelSurfaceList.nextId;

690 var gmailApp = ApplicationManager.startApplication("gmail-webapp");

698 var gmailApp = ApplicationManager.startApplication("gmail-webapp");

691 verify(gmailApp);

699 verify(gmailApp);

692

700

@@ -696,8 +704,9 @@ Rectangle {

696 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

704 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

697 compare(gmailApp.stage, ApplicationInfoInterface.MainStage);

705 compare(gmailApp.stage, ApplicationInfoInterface.MainStage);

698

706

699− waitUntilAppSurfaceShowsUp("gmail-webapp")

707+ waitUntilAppWindowIsFullyLoaded(gmailSurfaceId);

700

708

709+ var musicSurfaceId = topLevelSurfaceList.nextId;

701 var musicApp = ApplicationManager.startApplication("music-app");

710 var musicApp = ApplicationManager.startApplication("music-app");

702 verify(musicApp);

711 verify(musicApp);

703

712

@@ -707,7 +716,7 @@ Rectangle {

707 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

716 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

708 compare(musicApp.stage, ApplicationInfoInterface.MainStage);

717 compare(musicApp.stage, ApplicationInfoInterface.MainStage);

709

718

710− waitUntilAppSurfaceShowsUp("music-app")

719+ waitUntilAppWindowIsFullyLoaded(musicSurfaceId);

711 tryCompare(shell, "orientationChangesEnabled", true);

720 tryCompare(shell, "orientationChangesEnabled", true);

712

721

713 rotateTo(90);

722 rotateTo(90);

@@ -742,6 +751,7 @@ Rectangle {

742 */

751 */

743 function test_rotateToUnsupportedDeviceOrientation(data) {

752 function test_rotateToUnsupportedDeviceOrientation(data) {

744 loadShell("mako");

753 loadShell("mako");

754+ var twitterSurfaceId = topLevelSurfaceList.nextId;

745 var twitterApp = ApplicationManager.startApplication("twitter-webapp");

755 var twitterApp = ApplicationManager.startApplication("twitter-webapp");

746 verify(twitterApp);

756 verify(twitterApp);

747

757

@@ -750,7 +760,7 @@ Rectangle {

750 compare(twitterApp.supportedOrientations, Qt.PortraitOrientation | Qt.LandscapeOrientation

760 compare(twitterApp.supportedOrientations, Qt.PortraitOrientation | Qt.LandscapeOrientation

751 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

761 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

752

762

753− waitUntilAppSurfaceShowsUp("twitter-webapp")

763+ waitUntilAppWindowIsFullyLoaded(twitterSurfaceId);

754

764

755 rotateTo(data.rotationAngle);

765 rotateTo(data.rotationAngle);

756 tryCompare(shell, "transformRotationAngle", data.rotationAngle);

766 tryCompare(shell, "transformRotationAngle", data.rotationAngle);

@@ -767,13 +777,14 @@ Rectangle {

767

777

768 function test_launchLandscapeOnlyAppFromPortrait() {

778 function test_launchLandscapeOnlyAppFromPortrait() {

769 loadShell("mako");

779 loadShell("mako");

780+ var weatherSurfaceId = topLevelSurfaceList.nextId;

770 var weatherApp = ApplicationManager.startApplication("ubuntu-weather-app");

781 var weatherApp = ApplicationManager.startApplication("ubuntu-weather-app");

771 verify(weatherApp);

782 verify(weatherApp);

772

783

773 // ensure the mock app is as we expect

784 // ensure the mock app is as we expect

774 compare(weatherApp.supportedOrientations, Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation);

785 compare(weatherApp.supportedOrientations, Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation);

775

786

776− waitUntilAppSurfaceShowsUp("ubuntu-weather-app");

787+ waitUntilAppWindowIsFullyLoaded(weatherSurfaceId);

777

788

778 var rotationStates = findInvisibleChild(orientedShell, "rotationStates");

789 var rotationStates = findInvisibleChild(orientedShell, "rotationStates");

779 waitUntilTransitionsEnd(rotationStates);

790 waitUntilTransitionsEnd(rotationStates);

@@ -805,6 +816,7 @@ Rectangle {

805 */

816 */

806 function test_greeterStaysAwayAfterRotation() {

817 function test_greeterStaysAwayAfterRotation() {

807 loadShell("mako");

818 loadShell("mako");

819+ var twitterSurfaceId = topLevelSurfaceList.nextId;

808 var twitterApp = ApplicationManager.startApplication("twitter-webapp");

820 var twitterApp = ApplicationManager.startApplication("twitter-webapp");

809 verify(twitterApp);

821 verify(twitterApp);

810

822

@@ -813,8 +825,8 @@ Rectangle {

813 compare(twitterApp.supportedOrientations, Qt.PortraitOrientation | Qt.LandscapeOrientation

825 compare(twitterApp.supportedOrientations, Qt.PortraitOrientation | Qt.LandscapeOrientation

814 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

826 | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation);

815

827

816− waitUntilAppSurfaceShowsUp("twitter-webapp");

828+ waitUntilAppWindowIsFullyLoaded(twitterSurfaceId);

817− waitUntilAppWindowCanRotate("twitter-webapp");

829+ waitUntilAppWindowCanRotate(twitterSurfaceId);

818

830

819 // go back to unity8-dash

831 // go back to unity8-dash

820 performEdgeSwipeToSwitchToPreviousApp();

832 performEdgeSwipeToSwitchToPreviousApp();

@@ -830,7 +842,7 @@ Rectangle {

830 var greeter = findChild(shell, "greeter");

842 var greeter = findChild(shell, "greeter");

831 tryCompare(greeter, "animating", false);

843 tryCompare(greeter, "animating", false);

832

844

833− var twitterDelegate = findChild(shell, "appDelegate1");

845+ var twitterDelegate = findChild(shell, "spreadDelegate_" + topLevelSurfaceList.idAt(1));

834 compare(twitterDelegate.application.appId, "twitter-webapp");

846 compare(twitterDelegate.application.appId, "twitter-webapp");

835 twitterDelegate.clicked();

847 twitterDelegate.clicked();

836

848

@@ -1018,13 +1030,15 @@ Rectangle {

1018 function test_launchedAppHasActiveFocus(data) {

1030 function test_launchedAppHasActiveFocus(data) {

1019 loadShell(data.deviceName);

1031 loadShell(data.deviceName);

1020

1032

1033+ var gmailSurfaceId = topLevelSurfaceList.nextId;

1021 var gmailApp = ApplicationManager.startApplication("gmail-webapp");

1034 var gmailApp = ApplicationManager.startApplication("gmail-webapp");

1022 verify(gmailApp);

1035 verify(gmailApp);

1023− waitUntilAppSurfaceShowsUp("gmail-webapp")

1036+ waitUntilAppWindowIsFullyLoaded(gmailSurfaceId);

1024

1037

1025− verify(gmailApp.session.lastSurface);

1038+ var gmailSurface = gmailApp.surfaceList.get(0);

1039+ verify(gmailSurface);

1026

1040

1027− tryCompare(gmailApp.session.lastSurface, "activeFocus", true);

1041+ tryCompare(gmailSurface, "activeFocus", true);

1028 }

1042 }

1029

1043

1030 function test_launchLandscapeOnlyAppOverPortraitOnlyDashThenSwitchToDash() {

1044 function test_launchLandscapeOnlyAppOverPortraitOnlyDashThenSwitchToDash() {

@@ -1033,13 +1047,14 @@ Rectangle {

1033 // starts as portrait, as unity8-dash is portrait only

1047 // starts as portrait, as unity8-dash is portrait only

1034 tryCompare(shell, "transformRotationAngle", 0);

1048 tryCompare(shell, "transformRotationAngle", 0);

1035

1049

1050+ var weatherSurfaceId = topLevelSurfaceList.nextId;

1036 var weatherApp = ApplicationManager.startApplication("ubuntu-weather-app");

1051 var weatherApp = ApplicationManager.startApplication("ubuntu-weather-app");

1037 verify(weatherApp);

1052 verify(weatherApp);

1038

1053

1039 // ensure the mock app is as we expect

1054 // ensure the mock app is as we expect

1040 compare(weatherApp.supportedOrientations, Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation);

1055 compare(weatherApp.supportedOrientations, Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation);

1041

1056

1042− waitUntilAppSurfaceShowsUp("ubuntu-weather-app");

1057+ waitUntilAppWindowIsFullyLoaded(weatherSurfaceId);

1043

1058

1044 // should have rotated to landscape

1059 // should have rotated to landscape

1045 tryCompareFunction(function () { return shell.transformRotationAngle == 270

1060 tryCompareFunction(function () { return shell.transformRotationAngle == 270

@@ -1233,10 +1248,14 @@ Rectangle {

1233 function test_lockPhoneAfterClosingAppInSpreadThenUnlockAndRotate() {

1248 function test_lockPhoneAfterClosingAppInSpreadThenUnlockAndRotate() {

1234 loadShell("mako");

1249 loadShell("mako");

1235

1250

1251+ compare(topLevelSurfaceList.applicationAt(0).appId, "unity8-dash");

1252+ var dashSurfaceId = topLevelSurfaceList.idAt(0);

1253+

1254+ var gmailSurfaceId = topLevelSurfaceList.nextId;

1236 var gmailApp = ApplicationManager.startApplication("gmail-webapp");

1255 var gmailApp = ApplicationManager.startApplication("gmail-webapp");

1237 verify(gmailApp);

1256 verify(gmailApp);

1238

1257

1239− waitUntilAppSurfaceShowsUp("gmail-webapp");

1258+ waitUntilAppWindowIsFullyLoaded(gmailSurfaceId);

1240

1259

1241 performEdgeSwipeToShowAppSpread();

1260 performEdgeSwipeToShowAppSpread();

1242

1261

@@ -1252,7 +1271,7 @@ Rectangle {

1252

1271

1253 swipeAwayGreeter();

1272 swipeAwayGreeter();

1254

1273

1255− verify(isAppSurfaceFocused("unity8-dash"))

1274+ verify(isAppSurfaceFocused(dashSurfaceId))

1256

1275

1257 signalSpy.clear();

1276 signalSpy.clear();

1258 signalSpy.target = shell;

1277 signalSpy.target = shell;

@@ -1314,6 +1333,7 @@ Rectangle {

1314 ////

1333 ////

1315 // Launch a portrait-only application

1334 // Launch a portrait-only application

1316

1335

1336+ var dialerSurfaceId = topLevelSurfaceList.nextId;

1317 var dialerApp = ApplicationManager.startApplication("dialer-app");

1337 var dialerApp = ApplicationManager.startApplication("dialer-app");

1318 verify(dialerApp);

1338 verify(dialerApp);

1319

1339

@@ -1321,9 +1341,9 @@ Rectangle {

1321 compare(dialerApp.rotatesWindowContents, false);

1341 compare(dialerApp.rotatesWindowContents, false);

1322 compare(dialerApp.supportedOrientations, Qt.PortraitOrientation | Qt.InvertedPortraitOrientation);

1342 compare(dialerApp.supportedOrientations, Qt.PortraitOrientation | Qt.InvertedPortraitOrientation);

1323

1343

1324− waitUntilAppSurfaceShowsUp("dialer-app");

1344+ waitUntilAppWindowIsFullyLoaded(dialerSurfaceId);

1325− waitUntilAppWindowCanRotate("dialer-app");

1345+ waitUntilAppWindowCanRotate(dialerSurfaceId);

1326− verify(isAppSurfaceFocused("dialer-app"));

1346+ verify(isAppSurfaceFocused(dialerSurfaceId));

1327

1347

1328 ////

1348 ////

1329 // check outcome (shell should stay in landscape)

1349 // check outcome (shell should stay in landscape)

@@ -1376,17 +1396,29 @@ Rectangle {

1376 tryCompare(appWindowStates, "state", "surface");

1396 tryCompare(appWindowStates, "state", "surface");

1377 }

1397 }

1378

1398

1379− function waitUntilAppSurfaceShowsUp(appId) {

1399+ function findAppWindowForSurfaceId(surfaceId) {

1380− var appWindow = findChild(shell, "appWindow_" + appId);

1400+ // for PhoneStage and TabletStage

1381− verify(appWindow);

1401+ var delegate = findChild(shell, "spreadDelegate_" + surfaceId);

1382− var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

1402+ if (!delegate) {

1383− verify(appWindowStates);

1403+ // for DesktopStage

1384− tryCompare(appWindowStates, "state", "surface");

1404+ delegate = findChild(shell, "appDelegate_" + surfaceId);

1405+ }

1406+ verify(delegate);

1407+ var appWindow = findChild(delegate, "appWindow");

1408+ return appWindow;

1385 }

1409 }

1386

1410

1411+ // Wait until the ApplicationWindow for the given Application object is fully loaded

1412+ // (ie, the real surface has replaced the splash screen)

1413+ function waitUntilAppWindowIsFullyLoaded(surfaceId) {

1414+ var appWindow = findAppWindowForSurfaceId(surfaceId);

1415+ var appWindowStateGroup = findInvisibleChild(appWindow, "applicationWindowStateGroup");

1416+ tryCompareFunction(function() { return appWindowStateGroup.state === "surface" }, true);

1417+ waitUntilTransitionsEnd(appWindowStateGroup);

1418+ }

1419+

1387− function waitUntilAppWindowCanRotate(appId) {

1420+ function waitUntilAppWindowCanRotate(surfaceId) {

1388− var appWindow = findChild(shell, "appWindow_" + appId);

1421+ var appWindow = findAppWindowForSurfaceId(surfaceId);

1389− verify(appWindow);

1390 tryCompare(appWindow, "orientationChangesEnabled", true);

1422 tryCompare(appWindow, "orientationChangesEnabled", true);

1391 }

1423 }

1392

1424

@@ -1498,14 +1530,6 @@ Rectangle {

1498 tryCompare(greeter, "fullyShown", true);

1530 tryCompare(greeter, "fullyShown", true);

1499 }

1531 }

1500

1532

1501− function killApps() {

1502− while (ApplicationManager.count > 1) {

1503− var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0

1504− ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);

1505− }

1506− compare(ApplicationManager.count, 1)

1507− }

1508−

1509 function loadShell(deviceName) {

1533 function loadShell(deviceName) {

1510 applicationArguments.deviceName = deviceName;

1534 applicationArguments.deviceName = deviceName;

1511

1535

@@ -1517,6 +1541,12 @@ Rectangle {

1517

1541

1518 shell = findChild(orientedShell, "shell");

1542 shell = findChild(orientedShell, "shell");

1519

1543

1544+ topLevelSurfaceList = findInvisibleChild(shell, "topLevelSurfaceList");

1545+ verify(topLevelSurfaceList);

1546+

1547+ var stageLoader = findChild(shell, "applicationsDisplayLoader");

1548+ verify(stageLoader);

1549+

1520 tryCompare(shell, "enabled", true); // enabled by greeter when ready

1550 tryCompare(shell, "enabled", true); // enabled by greeter when ready

1521

1551

1522 waitUntilShellIsInOrientation(root.physicalOrientation0);

1552 waitUntilShellIsInOrientation(root.physicalOrientation0);

@@ -1525,7 +1555,7 @@ Rectangle {

1525

1555

1526 swipeAwayGreeter();

1556 swipeAwayGreeter();

1527

1557

1528− var spreadRepeater = findChild(shell, "spreadRepeater");

1558+ var spreadRepeater = findChild(stageLoader, "spreadRepeater");

1529 if (spreadRepeater) {

1559 if (spreadRepeater) {

1530 spreadRepeaterConnections.target = spreadRepeater;

1560 spreadRepeaterConnections.target = spreadRepeater;

1531 }

1561 }

@@ -1546,7 +1576,7 @@ Rectangle {

1546

1576

1547 // expectedAngle is in orientedShell's coordinate system

1577 // expectedAngle is in orientedShell's coordinate system

1548 function checkAppSurfaceOrientation(item, app, expectedAngle) {

1578 function checkAppSurfaceOrientation(item, app, expectedAngle) {

1549− var surface = app.session.lastSurface;

1579+ var surface = app.surfaceList.get(0);

1550 if (!surface) {

1580 if (!surface) {

1551 console.warn("no surface");

1581 console.warn("no surface");

1552 return false;

1582 return false;

@@ -1601,7 +1631,7 @@ Rectangle {

1601 var spreadView = findChild(shell, "spreadView");

1631 var spreadView = findChild(shell, "spreadView");

1602 verify(spreadView);

1632 verify(spreadView);

1603

1633

1604− var delegateToClose = findChild(spreadView, "appDelegate0");

1634+ var delegateToClose = findChild(spreadView, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

1605 verify(delegateToClose);

1635 verify(delegateToClose);

1606

1636

1607 var appIdToClose = ApplicationManager.get(0).appId;;

1637 var appIdToClose = ApplicationManager.get(0).appId;;

@@ -1627,20 +1657,11 @@ Rectangle {

1627 compare(ApplicationManager.findApplication(appIdToClose), null);

1657 compare(ApplicationManager.findApplication(appIdToClose), null);

1628 }

1658 }

1629

1659

1630− function isAppSurfaceFocused(appId) {

1660+ function isAppSurfaceFocused(surfaceId) {

1631− var appWindow = findChild(shell, "appWindow_" + appId);

1661+ var index = topLevelSurfaceList.indexForId(surfaceId);

1632− verify(appWindow);

1662+ var surface = topLevelSurfaceList.surfaceAt(index);

1633−

1634− var app = ApplicationManager.findApplication(appId);

1635− verify(app);

1636−

1637− var surface = app.session.lastSurface;

1638 verify(surface);

1663 verify(surface);

1639−

1640− var surfaceItem = findSurfaceItem(appWindow, surface);

1641− verify(surfaceItem);

1642−

1643− return surfaceItem.activeFocus;

1664+ return surface.activeFocus;

1644 }

1665 }

1645 }

1666 }

1646}

1667}

tests/qmltests/tst_Shell.qml+182−116

@@ -1,5 +1,5 @@

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

@@ -185,6 +185,17 @@ Rectangle {

185 }

186 }

187 }

188+ Button {

189+ text: "Show Launcher"

190+ activeFocusOnPress: false

191+ onClicked: {

192+ if (shellLoader.status !== Loader.Ready)

193+ return;

194+

195+ var launcher = testCase.findChild(shellLoader.item, "launcher");

196+ launcher.state = "visible";

197+ }

198+ }

188 ListItem.ItemSelector {

199 ListItem.ItemSelector {

189 anchors { left: parent.left; right: parent.right }

200 anchors { left: parent.left; right: parent.right }

190 activeFocusOnPress: false

201 activeFocusOnPress: false

@@ -381,12 +392,6 @@ Rectangle {

381 signalName: "actionInvoked"

392 signalName: "actionInvoked"

382 }

393 }

383

394

384− SignalSpy {

385− id: appRemovedSpy

386− target: ApplicationManager

387− signalName: "applicationRemoved"

388− }

389−

390 Telephony.CallEntry {

395 Telephony.CallEntry {

391 id: phoneCall

396 id: phoneCall

392 phoneNumber: "+447812221111"

397 phoneNumber: "+447812221111"

@@ -412,6 +417,7 @@ Rectangle {

412 when: windowShown

417 when: windowShown

413

418

414 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

419 property Item shell: shellLoader.status === Loader.Ready ? shellLoader.item : null

420+ property QtObject topLevelSurfaceList: null

415

421

416 function init() {

422 function init() {

417 if (shellLoader.active) {

423 if (shellLoader.active) {

@@ -449,6 +455,9 @@ Rectangle {

449 panel.dismissTimer = fakeDismissTimer;

455 panel.dismissTimer = fakeDismissTimer;

450

456

451 waitForGreeterToStabilize();

457 waitForGreeterToStabilize();

458+

459+ topLevelSurfaceList = findInvisibleChild(shell, "topLevelSurfaceList");

460+ verify(topLevelSurfaceList);

452 }

461 }

453

462

454 function loadDesktopShellWithApps() {

463 function loadDesktopShellWithApps() {

@@ -463,7 +472,9 @@ Rectangle {

463 var app5 = ApplicationManager.startApplication("camera-app")

472 var app5 = ApplicationManager.startApplication("camera-app")

464 var app6 = ApplicationManager.startApplication("gallery-app")

473 var app6 = ApplicationManager.startApplication("gallery-app")

465 var app7 = ApplicationManager.startApplication("calendar-app")

474 var app7 = ApplicationManager.startApplication("calendar-app")

475+ for (var i = 0; i < topLevelSurfaceList.count; ++i) {

466− waitUntilAppWindowIsFullyLoaded(app7);

476+ waitUntilAppWindowIsFullyLoaded(topLevelSurfaceList.idAt(i));

477+ }

467 }

478 }

468

479

469 function waitForGreeterToStabilize() {

480 function waitForGreeterToStabilize() {

@@ -503,7 +514,7 @@ Rectangle {

503 Wizard.System.wizardEnabled = false;

514 Wizard.System.wizardEnabled = false;

504

515

505 // kill all (fake) running apps

516 // kill all (fake) running apps

506− killApps(ApplicationManager);

517+ killApps();

507

518

508 unlockAllModemsSpy.clear()

519 unlockAllModemsSpy.clear()

509 LightDM.Greeter.authenticate(""); // reset greeter

520 LightDM.Greeter.authenticate(""); // reset greeter

@@ -511,14 +522,10 @@ Rectangle {

511 sessionSpy.clear();

522 sessionSpy.clear();

512

523

513 GSettingsController.setLifecycleExemptAppids([]);

524 GSettingsController.setLifecycleExemptAppids([]);

514− }

515

525

516− function killApps() {

526+ // there should be only unity8-dash window over there

517− while (ApplicationManager.count > 1) {

527+ tryCompare(ApplicationManager, "count", 1);

518− var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0

519− ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);

520− }

521− compare(ApplicationManager.count, 1)

528+ compare(ApplicationManager.get(0).appId, "unity8-dash");

522 }

529 }

523

530

524 function test_snapDecisionDismissalReturnsFocus() {

531 function test_snapDecisionDismissalReturnsFocus() {

@@ -527,10 +534,13 @@ Rectangle {

527 var notifications = findChild(shell, "notificationList");

534 var notifications = findChild(shell, "notificationList");

528 var app = ApplicationManager.startApplication("camera-app");

535 var app = ApplicationManager.startApplication("camera-app");

529 var stage = findChild(shell, "stage")

536 var stage = findChild(shell, "stage")

530− // Open an application and focus

537+ // Open an application

531 waitUntilApplicationWindowIsFullyVisible(app);

538 waitUntilApplicationWindowIsFullyVisible(app);

532− ApplicationManager.focusApplication(app);

539+

540+ var appSurface = app.surfaceList.get(0);

541+ verify(appSurface);

542+

533− tryCompare(app.session.lastSurface, "activeFocus", true);

543+ tryCompare(appSurface, "activeFocus", true);

534

544

535 notifications.model = mockNotificationsModel;

545 notifications.model = mockNotificationsModel;

536

546

@@ -552,7 +562,7 @@ Rectangle {

552 waitForRendering(notification);

562 waitForRendering(notification);

553

563

554 // Make sure activeFocus went away from the app window

564 // Make sure activeFocus went away from the app window

555− tryCompare(app.session.lastSurface, "activeFocus", false);

565+ tryCompare(appSurface, "activeFocus", false);

556 tryCompare(stage, "interactive", false);

566 tryCompare(stage, "interactive", false);

557

567

558 // Clicking the button should dismiss the notification and return focus

568 // Clicking the button should dismiss the notification and return focus

@@ -560,7 +570,7 @@ Rectangle {

560 mouseClick(buttonAccept);

570 mouseClick(buttonAccept);

561

571

562 // Make sure we're back to normal

572 // Make sure we're back to normal

563− tryCompare(app.session.lastSurface, "activeFocus", true);

573+ tryCompare(appSurface, "activeFocus", true);

564 compare(stage.interactive, true, "Stages not interactive again after modal notification has closed");

574 compare(stage.interactive, true, "Stages not interactive again after modal notification has closed");

565 }

575 }

566

576

@@ -644,9 +654,12 @@ Rectangle {

644 var launcher = findChild(shell, "launcherPanel");

654 var launcher = findChild(shell, "launcherPanel");

645 tryCompare(launcher, "x", data.launcherHides ? -launcher.width : 0)

655 tryCompare(launcher, "x", data.launcherHides ? -launcher.width : 0)

646

656

657+ //FIXME: This check fails. Don't understand the rationale behind it.

658+ /*

647 // Make sure the helper for sliding out the launcher wasn't touched. We want to fade it out here.

659 // Make sure the helper for sliding out the launcher wasn't touched. We want to fade it out here.

648 var animateTimer = findInvisibleChild(shell, "animateTimer");

660 var animateTimer = findInvisibleChild(shell, "animateTimer");

649 compare(animateTimer.nextState, "visible");

661 compare(animateTimer.nextState, "visible");

662+ */

650 }

663 }

651

664

652 function test_tabletLeftEdgeDrag_data() {

665 function test_tabletLeftEdgeDrag_data() {

@@ -873,10 +886,22 @@ Rectangle {

873 tryCompare(item, "visible", false);

886 tryCompare(item, "visible", false);

874 }

887 }

875

888

889+ function findAppWindowForSurfaceId(surfaceId) {

890+ // for PhoneStage and TabletStage

891+ var delegate = findChild(shell, "spreadDelegate_" + surfaceId);

892+ if (!delegate) {

893+ // for DesktopStage

894+ delegate = findChild(shell, "appDelegate_" + surfaceId);

895+ }

896+ verify(delegate);

897+ var appWindow = findChild(delegate, "appWindow");

898+ return appWindow;

899+ }

900+

876 // Wait until the ApplicationWindow for the given Application object is fully loaded

901 // Wait until the ApplicationWindow for the given Application object is fully loaded

877 // (ie, the real surface has replaced the splash screen)

902 // (ie, the real surface has replaced the splash screen)

878− function waitUntilAppWindowIsFullyLoaded(app) {

903+ function waitUntilAppWindowIsFullyLoaded(surfaceId) {

879− var appWindow = findChild(shell, "appWindow_" + app.appId);

904+ var appWindow = findAppWindowForSurfaceId(surfaceId);

880 var appWindowStateGroup = findInvisibleChild(appWindow, "applicationWindowStateGroup");

905 var appWindowStateGroup = findInvisibleChild(appWindow, "applicationWindowStateGroup");

881 tryCompareFunction(function() { return appWindowStateGroup.state === "surface" }, true);

906 tryCompareFunction(function() { return appWindowStateGroup.state === "surface" }, true);

882 waitUntilTransitionsEnd(appWindowStateGroup);

907 waitUntilTransitionsEnd(appWindowStateGroup);

@@ -885,10 +910,13 @@ Rectangle {

885 function test_surfaceLosesActiveFocusWhilePanelIsOpen() {

910 function test_surfaceLosesActiveFocusWhilePanelIsOpen() {

886 loadShell("phone");

911 loadShell("phone");

887 swipeAwayGreeter();

912 swipeAwayGreeter();

913+ var appSurfaceId = topLevelSurfaceList.nextId;

888 var app = ApplicationManager.startApplication("dialer-app");

914 var app = ApplicationManager.startApplication("dialer-app");

889− waitUntilAppWindowIsFullyLoaded(app);

915+ waitUntilAppWindowIsFullyLoaded(appSurfaceId);

916+ var appSurface = app.surfaceList.get(0);

917+ verify(appSurface);

890

918

891− tryCompare(app.session.lastSurface, "activeFocus", true);

919+ tryCompare(appSurface, "activeFocus", true);

892

920

893 // Drag the indicators panel half-open

921 // Drag the indicators panel half-open

894 var touchX = shell.width / 2;

922 var touchX = shell.width / 2;

@@ -899,7 +927,7 @@ Rectangle {

899 true /* beginTouch */, false /* endTouch */);

927 true /* beginTouch */, false /* endTouch */);

900 verify(indicators.partiallyOpened);

928 verify(indicators.partiallyOpened);

901

929

902− tryCompare(app.session.lastSurface, "activeFocus", false);

930+ tryCompare(appSurface, "activeFocus", false);

903

931

904 // And finish getting it open

932 // And finish getting it open

905 touchFlick(indicators,

933 touchFlick(indicators,

@@ -908,11 +936,11 @@ Rectangle {

908 false /* beginTouch */, true /* endTouch */);

936 false /* beginTouch */, true /* endTouch */);

909 tryCompare(indicators, "fullyOpened", true);

937 tryCompare(indicators, "fullyOpened", true);

910

938

911− tryCompare(app.session.lastSurface, "activeFocus", false);

939+ tryCompare(appSurface, "activeFocus", false);

912

940

913 dragToCloseIndicatorsPanel();

941 dragToCloseIndicatorsPanel();

914

942

915− tryCompare(app.session.lastSurface, "activeFocus", true);

943+ tryCompare(appSurface, "activeFocus", true);

916 }

944 }

917

945

918 function test_launchedAppHasActiveFocus_data() {

946 function test_launchedAppHasActiveFocus_data() {

@@ -928,54 +956,44 @@ Rectangle {

928 shell.usageScenario = data.usageScenario;

956 shell.usageScenario = data.usageScenario;

929 swipeAwayGreeter();

957 swipeAwayGreeter();

930

958

959+ var webAppSurfaceId = topLevelSurfaceList.nextId;

931 var webApp = ApplicationManager.startApplication("webbrowser-app");

960 var webApp = ApplicationManager.startApplication("webbrowser-app");

932 verify(webApp);

961 verify(webApp);

933− waitUntilAppSurfaceShowsUp("webbrowser-app")

962+ waitUntilAppWindowIsFullyLoaded(webAppSurfaceId);

934

963

935− verify(webApp.session.lastSurface);

964+ var webAppSurface = webApp.surfaceList.get(topLevelSurfaceList.indexForId(webAppSurfaceId));

965+ verify(webAppSurface);

936

966

937− tryCompare(webApp.session.lastSurface, "activeFocus", true);

967+ tryCompare(webAppSurface, "activeFocus", true);

938 }

968 }

939

969

940 function test_launchedAppKeepsActiveFocusOnUsageModeChange() {

970 function test_launchedAppKeepsActiveFocusOnUsageModeChange() {

941 loadShell("tablet");

971 loadShell("tablet");

942 swipeAwayGreeter();

972 swipeAwayGreeter();

943

973

974+ var webAppSurfaceId = topLevelSurfaceList.nextId;

944 var webApp = ApplicationManager.startApplication("webbrowser-app");

975 var webApp = ApplicationManager.startApplication("webbrowser-app");

945 verify(webApp);

976 verify(webApp);

946− waitUntilAppSurfaceShowsUp("webbrowser-app")

977+ waitUntilAppWindowIsFullyLoaded(webAppSurfaceId);

947

978

948− verify(webApp.session.lastSurface);

979+ var webAppSurface = webApp.surfaceList.get(topLevelSurfaceList.indexForId(webAppSurfaceId));

980+ verify(webAppSurface);

949

981

950− tryCompare(webApp.session.lastSurface, "activeFocus", true);

982+ tryCompare(webAppSurface, "activeFocus", true);

951

983

952 shell.usageScenario = "desktop";

984 shell.usageScenario = "desktop";

953

985

954 // check that the desktop stage and window have been loaded

986 // check that the desktop stage and window have been loaded

955− {

987+ waitUntilAppWindowIsFullyLoaded(webAppSurfaceId);

956− var desktopWindow = findChild(shell, "appWindow_webbrowser-app");

957− verify(desktopWindow);

958− }

959

988

960− tryCompare(webApp.session.lastSurface, "activeFocus", true);

989+ tryCompare(webAppSurface, "activeFocus", true);

961

990

962 shell.usageScenario = "tablet";

991 shell.usageScenario = "tablet";

963

992

964 // check that the tablet stage and app surface delegate have been loaded

993 // check that the tablet stage and app surface delegate have been loaded

965− {

994+ waitUntilAppWindowIsFullyLoaded(webAppSurfaceId);

966− var desktopWindow = findChild(shell, "tabletSpreadDelegate_webbrowser-app");

967− verify(desktopWindow);

968− }

969−

970− tryCompare(webApp.session.lastSurface, "activeFocus", true);

971− }

972

995

973− function waitUntilAppSurfaceShowsUp(appId) {

996+ tryCompare(webAppSurface, "activeFocus", true);

974− var appWindow = findChild(shell, "appWindow_" + appId);

975− verify(appWindow);

976− var appWindowStates = findInvisibleChild(appWindow, "applicationWindowStateGroup");

977− verify(appWindowStates);

978− tryCompare(appWindowStates, "state", "surface");

979 }

997 }

980

998

981 function dragToCloseIndicatorsPanel() {

999 function dragToCloseIndicatorsPanel() {

@@ -1026,7 +1044,7 @@ Rectangle {

1026 }

1044 }

1027

1045

1028 function waitUntilApplicationWindowIsFullyVisible() {

1046 function waitUntilApplicationWindowIsFullyVisible() {

1029− var appDelegate = findChild(shell, "appDelegate0")

1047+ var appDelegate = findChild(shell, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

1030 var surfaceContainer = findChild(appDelegate, "surfaceContainer");

1048 var surfaceContainer = findChild(appDelegate, "surfaceContainer");

1031 tryCompareFunction(function() { return surfaceContainer.surface !== null; }, true);

1049 tryCompareFunction(function() { return surfaceContainer.surface !== null; }, true);

1032 }

1050 }

@@ -1088,8 +1106,7 @@ Rectangle {

1088 var greeter = findChild(shell, "greeter");

1106 var greeter = findChild(shell, "greeter");

1089

1107

1090 var app = ApplicationManager.startApplication("dialer-app");

1108 var app = ApplicationManager.startApplication("dialer-app");

1091− // wait until the app is fully loaded (ie, real surface replaces splash screen)

1109+ waitUntilApplicationWindowIsFullyVisible(app);

1092− tryCompareFunction(function() { return app.session !== null && app.session.lastSurface !== null }, true);

1093

1110

1094 // Minimize the application we just launched

1111 // Minimize the application we just launched

1095 swipeFromLeftEdge(shell.width * 0.75);

1112 swipeFromLeftEdge(shell.width * 0.75);

@@ -1150,13 +1167,15 @@ Rectangle {

1150 swipeAwayGreeter();

1167 swipeAwayGreeter();

1151 var panel = findChild(shell, "panel");

1168 var panel = findChild(shell, "panel");

1152 compare(panel.fullscreenMode, false);

1169 compare(panel.fullscreenMode, false);

1153− ApplicationManager.startApplication("camera-app");

1170+ var cameraApp = ApplicationManager.startApplication("camera-app");

1171+ waitUntilApplicationWindowIsFullyVisible(cameraApp);

1154 tryCompare(panel, "fullscreenMode", true);

1172 tryCompare(panel, "fullscreenMode", true);

1155− ApplicationManager.startApplication("dialer-app");

1173+ var dialerApp = ApplicationManager.startApplication("dialer-app");

1174+ waitUntilApplicationWindowIsFullyVisible(dialerApp);

1156 tryCompare(panel, "fullscreenMode", false);

1175 tryCompare(panel, "fullscreenMode", false);

1157− ApplicationManager.requestFocusApplication("camera-app");

1176+ ApplicationManager.requestFocusApplication(cameraApp.appId);

1158 tryCompare(panel, "fullscreenMode", true);

1177 tryCompare(panel, "fullscreenMode", true);

1159− ApplicationManager.requestFocusApplication("dialer-app");

1178+ ApplicationManager.requestFocusApplication(dialerApp.appId);

1160 tryCompare(panel, "fullscreenMode", false);

1179 tryCompare(panel, "fullscreenMode", false);

1161 }

1180 }

1162

1181

@@ -1227,24 +1246,32 @@ Rectangle {

1227 var tutorial = findChild(shell, "tutorial");

1246 var tutorial = findChild(shell, "tutorial");

1228 tryCompare(wizard, "active", true);

1247 tryCompare(wizard, "active", true);

1229 tryCompare(tutorial, "running", true);

1248 tryCompare(tutorial, "running", true);

1230− tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");

1249+ tryCompareFunction(function() { return topLevelSurfaceList.applicationAt(0).appId; }, "unity8-dash");

1231

1250

1232− // Make sure we stay running when nothing focused (can happen for

1251+ // Make sure we stay running when there's no top level window (can happen for

1233 // a moment when we restart the dash after switching language)

1252 // a moment when we restart the dash after switching language)

1234− ApplicationManager.stopApplication("unity8-dash");

1253+ var dashApplication = ApplicationManager.findApplication("unity8-dash");

1235− tryCompare(ApplicationManager, "focusedApplicationId", "");

1254+ ApplicationManager.stopApplication(dashApplication.appId);

1255+ // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1256+ // They won't be gone until those surface items are destroyed.

1257+ tryCompareFunction(function() { return dashApplication.surfaceList.count }, 0);

1258+

1259+ tryCompare(topLevelSurfaceList, "count", 0);

1236 compare(wizard.shown, true);

1260 compare(wizard.shown, true);

1237 compare(tutorial.running, true);

1261 compare(tutorial.running, true);

1238

1262

1239− // And make sure we stay running when dash focused again

1263+ // And make sure we stay running when dash comes back again

1264+ var dashSurfaceId = topLevelSurfaceList.nextId;

1240− ApplicationManager.startApplication("unity8-dash");

1265+ ApplicationManager.startApplication(dashApplication.appId);

1241− tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");

1266+ waitUntilAppWindowIsFullyLoaded(dashSurfaceId);

1242 compare(wizard.shown, true);

1267 compare(wizard.shown, true);

1243 compare(tutorial.running, true);

1268 compare(tutorial.running, true);

1244

1269

1245− // And make sure we stop when something else is focused

1270+ // And make sure we stop when some other surface shows app

1271+ var gallerySurfaceId = topLevelSurfaceList.nextId;

1246− ApplicationManager.startApplication("gallery-app");

1272+ var galleryApp = ApplicationManager.startApplication("gallery-app");

1247− tryCompare(ApplicationManager, "focusedApplicationId", "gallery-app");

1273+ waitUntilAppWindowIsFullyLoaded(gallerySurfaceId);

1274+ tryCompareFunction(function() { return topLevelSurfaceList.applicationAt(0).appId; }, "gallery-app");

1248 compare(wizard.shown, false);

1275 compare(wizard.shown, false);

1249 compare(tutorial.running, false);

1276 compare(tutorial.running, false);

1250 tryCompare(AccountsService, "demoEdges", false);

1277 tryCompare(AccountsService, "demoEdges", false);

@@ -1269,7 +1296,7 @@ Rectangle {

1269 function test_tapOnRightEdgeReachesApplicationSurface() {

1296 function test_tapOnRightEdgeReachesApplicationSurface() {

1270 loadShell("phone");

1297 loadShell("phone");

1271 swipeAwayGreeter();

1298 swipeAwayGreeter();

1272− var topmostSpreadDelegate = findChild(shell, "appDelegate0");

1299+ var topmostSpreadDelegate = findChild(shell, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

1273 verify(topmostSpreadDelegate);

1300 verify(topmostSpreadDelegate);

1274

1301

1275 waitUntilFocusedApplicationIsShowingItsSurface();

1302 waitUntilFocusedApplicationIsShowingItsSurface();

@@ -1298,7 +1325,7 @@ Rectangle {

1298 function test_rightEdgeDragDoesNotReachApplicationSurface() {

1325 function test_rightEdgeDragDoesNotReachApplicationSurface() {

1299 loadShell("phone");

1326 loadShell("phone");

1300 swipeAwayGreeter();

1327 swipeAwayGreeter();

1301− var topmostSpreadDelegate = findChild(shell, "appDelegate0");

1328+ var topmostSpreadDelegate = findChild(shell, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

1302 var topmostSurfaceItem = findChild(topmostSpreadDelegate, "surfaceItem");

1329 var topmostSurfaceItem = findChild(topmostSpreadDelegate, "surfaceItem");

1303 var rightEdgeDragArea = findChild(shell, "spreadDragArea");

1330 var rightEdgeDragArea = findChild(shell, "spreadDragArea");

1304

1331

@@ -1318,7 +1345,7 @@ Rectangle {

1318

1345

1319 function waitUntilFocusedApplicationIsShowingItsSurface()

1346 function waitUntilFocusedApplicationIsShowingItsSurface()

1320 {

1347 {

1321− var spreadDelegate = findChild(shell, "appDelegate0");

1348+ var spreadDelegate = findChild(shell, "spreadDelegate_" + topLevelSurfaceList.idAt(0));

1322 var appState = findInvisibleChild(spreadDelegate, "applicationWindowStateGroup");

1349 var appState = findInvisibleChild(spreadDelegate, "applicationWindowStateGroup");

1323 tryCompare(appState, "state", "surface");

1350 tryCompare(appState, "state", "surface");

1324 var transitions = appState.transitions;

1351 var transitions = appState.transitions;

@@ -1467,11 +1494,13 @@ Rectangle {

1467 loadShell("tablet");

1494 loadShell("tablet");

1468 shell.usageScenario = "desktop";

1495 shell.usageScenario = "desktop";

1469

1496

1497+ var webBrowserSurfaceId = topLevelSurfaceList.nextId;

1470 var webBrowserApp = ApplicationManager.startApplication("webbrowser-app");

1498 var webBrowserApp = ApplicationManager.startApplication("webbrowser-app");

1471− waitUntilAppWindowIsFullyLoaded(webBrowserApp);

1499+ waitUntilAppWindowIsFullyLoaded(webBrowserSurfaceId);

1472

1500

1501+ var gallerySurfaceId = topLevelSurfaceList.nextId;

1473 var galleryApp = ApplicationManager.startApplication("gallery-app");

1502 var galleryApp = ApplicationManager.startApplication("gallery-app");

1474− waitUntilAppWindowIsFullyLoaded(galleryApp);

1503+ waitUntilAppWindowIsFullyLoaded(gallerySurfaceId);

1475

1504

1476 ApplicationManager.requestFocusApplication("unity8-dash");

1505 ApplicationManager.requestFocusApplication("unity8-dash");

1477 tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");

1506 tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");

@@ -1489,11 +1518,13 @@ Rectangle {

1489 loadShell("tablet");

1518 loadShell("tablet");

1490 shell.usageScenario = "tablet";

1519 shell.usageScenario = "tablet";

1491

1520

1521+ var webBrowserSurfaceId = topLevelSurfaceList.nextId;

1492 var webBrowserApp = ApplicationManager.startApplication("webbrowser-app");

1522 var webBrowserApp = ApplicationManager.startApplication("webbrowser-app");

1493− waitUntilAppWindowIsFullyLoaded(webBrowserApp);

1523+ waitUntilAppWindowIsFullyLoaded(webBrowserSurfaceId);

1494

1524

1525+ var gallerySurfaceId = topLevelSurfaceList.nextId;

1495 var galleryApp = ApplicationManager.startApplication("gallery-app");

1526 var galleryApp = ApplicationManager.startApplication("gallery-app");

1496− waitUntilAppWindowIsFullyLoaded(galleryApp);

1527+ waitUntilAppWindowIsFullyLoaded(gallerySurfaceId);

1497

1528

1498 ApplicationManager.requestFocusApplication("unity8-dash");

1529 ApplicationManager.requestFocusApplication("unity8-dash");

1499 tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");

1530 tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");

@@ -1523,17 +1554,26 @@ Rectangle {

1523 var desktopStage = findChild(shell, "stage");

1554 var desktopStage = findChild(shell, "stage");

1524 verify(desktopStage != null)

1555 verify(desktopStage != null)

1525

1556

1557+ var app1SurfaceId = topLevelSurfaceList.nextId;

1526 var app1 = ApplicationManager.startApplication("dialer-app")

1558 var app1 = ApplicationManager.startApplication("dialer-app")

1527− waitUntilAppWindowIsFullyLoaded(app1);

1559+ waitUntilAppWindowIsFullyLoaded(app1SurfaceId);

1560+

1561+ var app2SurfaceId = topLevelSurfaceList.nextId;

1528 var app2 = ApplicationManager.startApplication("webbrowser-app")

1562 var app2 = ApplicationManager.startApplication("webbrowser-app")

1529− waitUntilAppWindowIsFullyLoaded(app2);

1563+ waitUntilAppWindowIsFullyLoaded(app2SurfaceId);

1564+ var app2Surface = app2.surfaceList.get(0);

1565+ verify(app2Surface);

1566+

1567+ var app3SurfaceId = topLevelSurfaceList.nextId;

1530 var app3 = ApplicationManager.startApplication("camera-app")

1568 var app3 = ApplicationManager.startApplication("camera-app")

1531− waitUntilAppWindowIsFullyLoaded(app3);

1569+ waitUntilAppWindowIsFullyLoaded(app3SurfaceId);

1570+ var app3Surface = app3.surfaceList.get(0);

1571+ verify(app3Surface);

1532

1572

1533 // Do a quick alt-tab and see if focus changes

1573 // Do a quick alt-tab and see if focus changes

1534− tryCompare(app3.session.lastSurface, "activeFocus", true)

1574+ tryCompare(app3Surface, "activeFocus", true)

1535 keyClick(Qt.Key_Tab, Qt.AltModifier)

1575 keyClick(Qt.Key_Tab, Qt.AltModifier)

1536− tryCompare(app2.session.lastSurface, "activeFocus", true)

1576+ tryCompare(app2Surface, "activeFocus", true)

1537

1577

1538 // Press Alt+Tab

1578 // Press Alt+Tab

1539 keyPress(Qt.Key_Alt);

1579 keyPress(Qt.Key_Alt);

@@ -1541,7 +1581,7 @@ Rectangle {

1541 keyRelease(Qt.Key_Alt)

1581 keyRelease(Qt.Key_Alt)

1542

1582

1543 // Focus should have switched back now

1583 // Focus should have switched back now

1544− tryCompare(app3.session.lastSurface, "activeFocus", true)

1584+ tryCompare(app3Surface, "activeFocus", true)

1545 }

1585 }

1546

1586

1547 function test_altTabWrapAround() {

1587 function test_altTabWrapAround() {

@@ -1590,7 +1630,9 @@ Rectangle {

1590 tryCompare(desktopSpread, "state", "")

1630 tryCompare(desktopSpread, "state", "")

1591

1631

1592 // Make sure that after wrapping around once, we have the same one focused as at the beginning

1632 // Make sure that after wrapping around once, we have the same one focused as at the beginning

1593− tryCompare(focused.session.lastSurface, "activeFocus", true)

1633+ var focusedAppSurface = focused.surfaceList.get(0);

1634+ verify(focusedAppSurface);

1635+ tryCompare(focusedAppSurface, "activeFocus", true)

1594 }

1636 }

1595

1637

1596 function test_altBackTabNavigation() {

1638 function test_altBackTabNavigation() {

@@ -1624,7 +1666,7 @@ Rectangle {

1624 keyRelease(Qt.Key_Alt);

1666 keyRelease(Qt.Key_Alt);

1625 }

1667 }

1626

1668

1627− function test_highlightFollowsMouse() {

1669+ function otest_highlightFollowsMouse() {

1628 loadDesktopShellWithApps()

1670 loadDesktopShellWithApps()

1629

1671

1630 var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");

1672 var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");

@@ -1661,9 +1703,7 @@ Rectangle {

1661 keyPress(Qt.Key_Alt)

1703 keyPress(Qt.Key_Alt)

1662 keyClick(Qt.Key_Tab);

1704 keyClick(Qt.Key_Tab);

1663

1705

1664− appRemovedSpy.clear();

1706+ var surfaceId = topLevelSurfaceList.idAt(2);

1665−

1666− var closedAppId = ApplicationManager.get(2).appId;

1667 var spreadDelegate2 = spreadRepeater.itemAt(2);

1707 var spreadDelegate2 = spreadRepeater.itemAt(2);

1668 var closeMouseArea = findChild(spreadDelegate2, "closeMouseArea");

1708 var closeMouseArea = findChild(spreadDelegate2, "closeMouseArea");

1669

1709

@@ -1678,12 +1718,14 @@ Rectangle {

1678 }

1718 }

1679 tryCompare(closeMouseArea, "enabled", true)

1719 tryCompare(closeMouseArea, "enabled", true)

1680

1720

1721+ var countBeforeClickingCloseButton = topLevelSurfaceList.count;

1722+ verify(topLevelSurfaceList.indexForId(surfaceId) === 2);

1723+

1681 // Close the app using the close button

1724 // Close the app using the close button

1682 mouseClick(closeMouseArea, closeMouseArea.width / 2, closeMouseArea.height / 2)

1725 mouseClick(closeMouseArea, closeMouseArea.width / 2, closeMouseArea.height / 2)

1683

1726

1684− // Verify applicationRemoved has been emitted correctly

1727+ tryCompare(topLevelSurfaceList, "count", countBeforeClickingCloseButton - 1);

1685− tryCompare(appRemovedSpy, "count", 1)

1728+ verify(topLevelSurfaceList.indexForId(surfaceId) === -1);

1686− compare(appRemovedSpy.signalArguments[0][0], closedAppId);

1687

1729

1688 keyRelease(Qt.Key_Alt);

1730 keyRelease(Qt.Key_Alt);

1689 }

1731 }

@@ -1708,7 +1750,7 @@ Rectangle {

1708 keyPress(Qt.Key_Alt)

1750 keyPress(Qt.Key_Alt)

1709 keyClick(Qt.Key_Tab);

1751 keyClick(Qt.Key_Tab);

1710

1752

1711− var focusAppId = ApplicationManager.get(2).appId;

1753+ var surface = topLevelSurfaceList.surfaceAt(2);

1712 var spreadDelegate2 = spreadRepeater.itemAt(2);

1754 var spreadDelegate2 = spreadRepeater.itemAt(2);

1713 var clippedSpreadDelegate = findChild(spreadDelegate2, "clippedSpreadDelegate");

1755 var clippedSpreadDelegate = findChild(spreadDelegate2, "clippedSpreadDelegate");

1714

1756

@@ -1730,7 +1772,7 @@ Rectangle {

1730

1772

1731 // Verify that we left the spread and app2 is the focused one now

1773 // Verify that we left the spread and app2 is the focused one now

1732 tryCompare(stage, "state", "");

1774 tryCompare(stage, "state", "");

1733− tryCompare(ApplicationManager, "focusedApplicationId", focusAppId);

1775+ tryCompare(surface, "focused", true);

1734

1776

1735 keyRelease(Qt.Key_Alt);

1777 keyRelease(Qt.Key_Alt);

1736 }

1778 }

@@ -1794,7 +1836,7 @@ Rectangle {

1794 function test_workspacePreviewsHighlightedApp() {

1836 function test_workspacePreviewsHighlightedApp() {

1795 loadDesktopShellWithApps()

1837 loadDesktopShellWithApps()

1796

1838

1797− var targetZ = ApplicationManager.count + 1;

1839+ var targetZ = topLevelSurfaceList.count + 1;

1798

1840

1799 var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");

1841 var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");

1800 verify(spreadRepeater !== null);

1842 verify(spreadRepeater !== null);

@@ -1870,7 +1912,8 @@ Rectangle {

1870 loadDesktopShellWithApps();

1912 loadDesktopShellWithApps();

1871

1913

1872 var appRepeater = findChild(shell, "appRepeater")

1914 var appRepeater = findChild(shell, "appRepeater")

1873− var appId = ApplicationManager.get(0).appId;

1915+ var application = topLevelSurfaceList.applicationAt(0);

1916+ var surfaceId = topLevelSurfaceList.idAt(0);

1874 var appDelegate = appRepeater.itemAt(0);

1917 var appDelegate = appRepeater.itemAt(0);

1875 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1918 var maximizeButton = findChild(appDelegate, "maximizeWindowButton");

1876

1919

@@ -1881,17 +1924,20 @@ Rectangle {

1881 tryCompare(appDelegate, "state", "maximized");

1924 tryCompare(appDelegate, "state", "maximized");

1882 tryCompare(PanelState, "buttonsVisible", true)

1925 tryCompare(PanelState, "buttonsVisible", true)

1883

1926

1884− ApplicationManager.stopApplication(appId);

1927+ ApplicationManager.stopApplication(application.appId);

1885 tryCompare(PanelState, "buttonsVisible", false)

1928 tryCompare(PanelState, "buttonsVisible", false)

1886

1929

1930+ // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

1931+ // They won't be gone until those surface items are destroyed.

1932+ tryCompareFunction(function() { return application.surfaceList.count }, 0);

1933+

1887− ApplicationManager.startApplication(appId);

1934+ ApplicationManager.startApplication(application.appId);

1888 tryCompare(PanelState, "buttonsVisible", true)

1935 tryCompare(PanelState, "buttonsVisible", true)

1889 }

1936 }

1890

1937

1891 function test_newAppHasValidGeometry() {

1938 function test_newAppHasValidGeometry() {

1892 loadDesktopShellWithApps();

1939 loadDesktopShellWithApps();

1893 var appRepeater = findChild(shell, "appRepeater");

1940 var appRepeater = findChild(shell, "appRepeater");

1894− var appId = ApplicationManager.get(0).appId;

1895 var appDelegate = appRepeater.itemAt(0);

1941 var appDelegate = appRepeater.itemAt(0);

1896

1942

1897 var resizeArea = findChild(appDelegate, "windowResizeArea");

1943 var resizeArea = findChild(appDelegate, "windowResizeArea");

@@ -1908,7 +1954,6 @@ Rectangle {

1908 function test_switchToStagedHidesPanelButtons() {

1954 function test_switchToStagedHidesPanelButtons() {

1909 loadDesktopShellWithApps();

1955 loadDesktopShellWithApps();

1910 var appRepeater = findChild(shell, "appRepeater")

1956 var appRepeater = findChild(shell, "appRepeater")

1911− var appId = ApplicationManager.get(0).appId;

1912 var appDelegate = appRepeater.itemAt(0);

1957 var appDelegate = appRepeater.itemAt(0);

1913 var panelButtons = findChild(shell, "panelWindowControlButtons")

1958 var panelButtons = findChild(shell, "panelWindowControlButtons")

1914

1959

@@ -1925,7 +1970,6 @@ Rectangle {

1925 function test_lockingGreeterHidesPanelButtons() {

1970 function test_lockingGreeterHidesPanelButtons() {

1926 loadDesktopShellWithApps();

1971 loadDesktopShellWithApps();

1927 var appRepeater = findChild(shell, "appRepeater")

1972 var appRepeater = findChild(shell, "appRepeater")

1928− var appId = ApplicationManager.get(0).appId;

1929 var appDelegate = appRepeater.itemAt(0);

1973 var appDelegate = appRepeater.itemAt(0);

1930 var panelButtons = findChild(shell, "panelWindowControlButtons")

1974 var panelButtons = findChild(shell, "panelWindowControlButtons")

1931

1975

@@ -1955,12 +1999,15 @@ Rectangle {

1955 shell.usageScenario = "desktop";

1999 shell.usageScenario = "desktop";

1956 waitForRendering(shell);

2000 waitForRendering(shell);

1957

2001

2002+ var appSurfaceId = topLevelSurfaceList.nextId;

1958 var app = ApplicationManager.startApplication("dialer-app")

2003 var app = ApplicationManager.startApplication("dialer-app")

1959− waitUntilAppWindowIsFullyLoaded(app);

2004+ waitUntilAppWindowIsFullyLoaded(appSurfaceId);

1960

2005

1961 var appContainer = findChild(shell, "appContainer");

2006 var appContainer = findChild(shell, "appContainer");

2007+ verify(appContainer);

1962− var appDelegate = findChild(appContainer, "appDelegate_dialer-app");

2008+ var appDelegate = findChild(appContainer, "appDelegate_" + appSurfaceId);

2009+ verify(appDelegate);

1963− var decoration = findChild(appDelegate, "appWindowDecoration_dialer-app");

2010+ var decoration = findChild(appDelegate, "appWindowDecoration");

1964 verify(decoration);

2011 verify(decoration);

1965

2012

1966 // move it away from launcher and panel

2013 // move it away from launcher and panel

@@ -1978,18 +2025,22 @@ Rectangle {

1978 function test_restoreWindowStateFixesIfUnderPanel() {

2025 function test_restoreWindowStateFixesIfUnderPanel() {

1979 loadDesktopShellWithApps();

2026 loadDesktopShellWithApps();

1980 var appRepeater = findChild(shell, "appRepeater")

2027 var appRepeater = findChild(shell, "appRepeater")

1981− var appId = ApplicationManager.get(0).appId;

2028+ var application = topLevelSurfaceList.applicationAt(0);

1982 var appDelegate = appRepeater.itemAt(0);

2029 var appDelegate = appRepeater.itemAt(0);

1983

2030

1984 // Move it under the panel programmatically (might happen later with an alt+drag)

2031 // Move it under the panel programmatically (might happen later with an alt+drag)

1985 appDelegate.y = -units.gu(10)

2032 appDelegate.y = -units.gu(10)

1986

2033

1987− ApplicationManager.stopApplication(appId)

2034+ ApplicationManager.stopApplication(application.appId);

2035+ // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

2036+ // They won't be gone until those surface items are destroyed.

2037+ tryCompareFunction(function() { return application.surfaceList.count }, 0);

2038+

1988− ApplicationManager.startApplication(appId)

2039+ ApplicationManager.startApplication(application.appId);

1989 waitForRendering(shell)

2040 waitForRendering(shell)

1990

2041

1991 // Make sure the newly started one is at index 0 again

2042 // Make sure the newly started one is at index 0 again

1992− tryCompare(ApplicationManager.get(0), "appId", appId);

2043+ tryCompare(topLevelSurfaceList.applicationAt(0), "appId", application.appId);

1993

2044

1994 appDelegate = appRepeater.itemAt(0);

2045 appDelegate = appRepeater.itemAt(0);

1995 compare(appDelegate.y >= PanelState.panelHeight, true);

2046 compare(appDelegate.y >= PanelState.panelHeight, true);

@@ -2008,16 +2059,22 @@ Rectangle {

2008

2059

2009 // Add two main stage apps, the second in order to suspend the first.

2060 // Add two main stage apps, the second in order to suspend the first.

2010 // LibreOffice has isTouchApp set to false by our mocks.

2061 // LibreOffice has isTouchApp set to false by our mocks.

2062+ var app1SurfaceId = topLevelSurfaceList.nextId;

2011 var app1 = ApplicationManager.startApplication("libreoffice");

2063 var app1 = ApplicationManager.startApplication("libreoffice");

2012− waitUntilAppWindowIsFullyLoaded(app1);

2064+ waitUntilAppWindowIsFullyLoaded(app1SurfaceId);

2065+ var app2SurfaceId = topLevelSurfaceList.nextId;

2013 var app2 = ApplicationManager.startApplication("gallery-app");

2066 var app2 = ApplicationManager.startApplication("gallery-app");

2014− waitUntilAppWindowIsFullyLoaded(app2);

2067+ waitUntilAppWindowIsFullyLoaded(app2SurfaceId);

2015

2068

2016 // Sanity checking

2069 // Sanity checking

2017 compare(app1.stage, ApplicationInfoInterface.MainStage);

2070 compare(app1.stage, ApplicationInfoInterface.MainStage);

2018 compare(app2.stage, ApplicationInfoInterface.MainStage);

2071 compare(app2.stage, ApplicationInfoInterface.MainStage);

2019 verify(!app1.isTouchApp);

2072 verify(!app1.isTouchApp);

2073+

2074+ var app1Surface = app1.surfaceList.get(0);

2075+ verify(app1Surface);

2076+

2020− verify(!app1.session.lastSurface.activeFocus);

2077+ verify(!app1Surface.activeFocus);

2021

2078

2022 // Make sure app1 is exempt with a requested suspend

2079 // Make sure app1 is exempt with a requested suspend

2023 verify(app1.exemptFromLifecycle);

2080 verify(app1.exemptFromLifecycle);

@@ -2038,15 +2095,21 @@ Rectangle {

2038 GSettingsController.setLifecycleExemptAppids(["webbrowser-app"]);

2095 GSettingsController.setLifecycleExemptAppids(["webbrowser-app"]);

2039

2096

2040 // Add two main stage apps, the second in order to suspend the first

2097 // Add two main stage apps, the second in order to suspend the first

2098+ var app1SurfaceId = topLevelSurfaceList.nextId;

2041 var app1 = ApplicationManager.startApplication("webbrowser-app");

2099 var app1 = ApplicationManager.startApplication("webbrowser-app");

2042− waitUntilAppWindowIsFullyLoaded(app1);

2100+ waitUntilAppWindowIsFullyLoaded(app1SurfaceId);

2101+ var app2SurfaceId = topLevelSurfaceList.nextId;

2043 var app2 = ApplicationManager.startApplication("gallery-app");

2102 var app2 = ApplicationManager.startApplication("gallery-app");

2044− waitUntilAppWindowIsFullyLoaded(app2);

2103+ waitUntilAppWindowIsFullyLoaded(app2SurfaceId);

2045

2104

2046 // Sanity checking

2105 // Sanity checking

2047 compare(app1.stage, ApplicationInfoInterface.MainStage);

2106 compare(app1.stage, ApplicationInfoInterface.MainStage);

2048 compare(app2.stage, ApplicationInfoInterface.MainStage);

2107 compare(app2.stage, ApplicationInfoInterface.MainStage);

2108+

2109+ var app1Surface = app1.surfaceList.get(0);

2110+ verify(app1Surface);

2111+

2049− verify(!app1.session.lastSurface.activeFocus);

2112+ verify(!app1Surface.activeFocus);

2050

2113

2051 // Make sure app1 is exempt with a requested suspend

2114 // Make sure app1 is exempt with a requested suspend

2052 verify(app1.exemptFromLifecycle);

2115 verify(app1.exemptFromLifecycle);

@@ -2205,9 +2268,10 @@ Rectangle {

2205 var appContainer = findChild(shell, "appContainer");

2268 var appContainer = findChild(shell, "appContainer");

2206 var launcher = findChild(shell, "launcher");

2269 var launcher = findChild(shell, "launcher");

2207

2270

2271+ var appSurfaceId = topLevelSurfaceList.nextId;

2208 var app = ApplicationManager.startApplication("music-app");

2272 var app = ApplicationManager.startApplication("music-app");

2209− waitUntilAppWindowIsFullyLoaded(app);

2273+ waitUntilAppWindowIsFullyLoaded(appSurfaceId);

2210− var appDelegate = findChild(appContainer, "appDelegate_music-app");

2274+ var appDelegate = findChild(appContainer, "appDelegate_" + appSurfaceId);

2211 appDelegate.maximize();

2275 appDelegate.maximize();

2212 tryCompare(appDelegate, "visuallyMaximized", true);

2276 tryCompare(appDelegate, "visuallyMaximized", true);

2213 waitForRendering(shell);

2277 waitForRendering(shell);

@@ -2235,8 +2299,9 @@ Rectangle {

2235

2299

2236 tryCompare(launcher, "lockedVisible", true);

2300 tryCompare(launcher, "lockedVisible", true);

2237

2301

2302+ var cameraSurfaceId = topLevelSurfaceList.nextId;

2238 var cameraApp = ApplicationManager.startApplication("camera-app");

2303 var cameraApp = ApplicationManager.startApplication("camera-app");

2239− waitUntilAppWindowIsFullyLoaded(cameraApp);

2304+ waitUntilAppWindowIsFullyLoaded(cameraSurfaceId);

2240

2305

2241 tryCompare(launcher, "lockedVisible", false);

2306 tryCompare(launcher, "lockedVisible", false);

2242 }

2307 }

@@ -2257,8 +2322,9 @@ Rectangle {

2257 swipeAwayGreeter();

2322 swipeAwayGreeter();

2258

2323

2259 // Let's open a fullscreen app

2324 // Let's open a fullscreen app

2325+ var appSurfaceId = topLevelSurfaceList.nextId;

2260 var app = ApplicationManager.startApplication("camera-app");

2326 var app = ApplicationManager.startApplication("camera-app");

2261− waitUntilAppWindowIsFullyLoaded(app);

2327+ waitUntilAppWindowIsFullyLoaded(appSurfaceId);

2262

2328

2263 var appRepeater = findChild(shell, data.repeaterName);

2329 var appRepeater = findChild(shell, data.repeaterName);

2264 var topmostAppDelegate = appRepeater.itemAt(0);

2330 var topmostAppDelegate = appRepeater.itemAt(0);

tests/qmltests/tst_ShellWithPin.qml+9−13

@@ -197,14 +197,6 @@ Item {

197 removeTimeConstraintsFromDirectionalDragAreas(shellLoader.item)

198 }

199

200− function killApps() {

201− while (ApplicationManager.count > 1) {

202− var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0

203− ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);

204− }

205− compare(ApplicationManager.count, 1)

206− }

207−

208 function swipeAwayGreeter(waitForCoverPage) {

200 function swipeAwayGreeter(waitForCoverPage) {

209 var greeter = findChild(shell, "greeter");

201 var greeter = findChild(shell, "greeter");

210 waitForRendering(greeter)

202 waitForRendering(greeter)

@@ -318,6 +310,7 @@ Item {

318 var emergencyButton = findChild(greeter, "emergencyCallLabel");

310 var emergencyButton = findChild(greeter, "emergencyCallLabel");

319 tap(emergencyButton)

311 tap(emergencyButton)

320

312

313+

321 tryCompare(greeter, "shown", false);

314 tryCompare(greeter, "shown", false);

322 killApps() // kill dialer-app, as if it crashed

315 killApps() // kill dialer-app, as if it crashed

323 tryCompare(greeter, "shown", true);

316 tryCompare(greeter, "shown", true);

@@ -424,12 +417,15 @@ Item {

424

417

425 var greeter = findChild(shell, "greeter");

418 var greeter = findChild(shell, "greeter");

426 var lockscreen = findChild(shell, "lockscreen");

419 var lockscreen = findChild(shell, "lockscreen");

420+ verify(lockscreen);

427

421

428 lockscreen.emergencyCall();

422 lockscreen.emergencyCall();

429 confirmLockedApp("dialer-app");

423 confirmLockedApp("dialer-app");

430 callManager.foregroundCall = phoneCall;

424 callManager.foregroundCall = phoneCall;

431

425

432 LightDM.Greeter.showGreeter();

426 LightDM.Greeter.showGreeter();

427+ lockscreen = findChild(shell, "lockscreen");

428+ verify(lockscreen);

433 tryCompare(lockscreen, "shown", true);

429 tryCompare(lockscreen, "shown", true);

434 tryCompare(greeter, "hasLockedApp", false);

430 tryCompare(greeter, "hasLockedApp", false);

435

431

@@ -476,7 +472,7 @@ Item {

476

472

477 var app = ApplicationManager.startApplication("gallery-app");

473 var app = ApplicationManager.startApplication("gallery-app");

478 // wait until the app is fully loaded (ie, real surface replaces splash screen)

474 // wait until the app is fully loaded (ie, real surface replaces splash screen)

479− tryCompareFunction(function() { return app.session !== null && app.session.lastSurface !== null }, true);

475+ tryCompareFunction(function() { return app.session !== null && app.surfaceList.count > 0 }, true);

480

476

481 // New app hides coverPage?

477 // New app hides coverPage?

482 var greeter = findChild(shell, "greeter");

478 var greeter = findChild(shell, "greeter");

@@ -593,8 +589,8 @@ Item {

593 var coverPage = findChild(shell, "coverPage");

589 var coverPage = findChild(shell, "coverPage");

594 var lockscreen = findChild(shell, "lockscreen");

590 var lockscreen = findChild(shell, "lockscreen");

595 var launcher = findChild(shell, "launcherPanel");

591 var launcher = findChild(shell, "launcherPanel");

596− ApplicationManager.startApplication("gallery-app");

592+ var galleryApp = ApplicationManager.startApplication("gallery-app");

597− tryCompare(ApplicationManager, "focusedApplicationId", "gallery-app");

593+ tryCompare(shell, "mainApp", galleryApp);

598

594

599 // Show greeter

595 // Show greeter

600 LightDM.Greeter.showGreeter();

596 LightDM.Greeter.showGreeter();

@@ -605,13 +601,13 @@ Item {

605 tryCompare(launcher, "x", -launcher.width);

601 tryCompare(launcher, "x", -launcher.width);

606 tryCompare(coverPage, "showProgress", 0);

602 tryCompare(coverPage, "showProgress", 0);

607 compare(lockscreen.shown, true);

603 compare(lockscreen.shown, true);

608− compare(ApplicationManager.focusedApplicationId, "gallery-app");

604+ tryCompare(shell, "mainApp", galleryApp);

609

605

610 // Now attempt a swipe on lockscreen

606 // Now attempt a swipe on lockscreen

611 touchFlick(shell, 2, shell.height / 2, units.gu(30), shell.height / 2);

607 touchFlick(shell, 2, shell.height / 2, units.gu(30), shell.height / 2);

612 tryCompare(launcher, "x", 0);

608 tryCompare(launcher, "x", 0);

613 compare(lockscreen.shown, true);

609 compare(lockscreen.shown, true);

614− compare(ApplicationManager.focusedApplicationId, "gallery-app");

610+ tryCompare(shell, "mainApp", galleryApp);

615 }

611 }

616 }

612 }

617}

613}

tests/utils/modules/Unity/Test/UnityTestCase.qml+20−2

@@ -1,5 +1,5 @@

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

@@ -16,12 +16,14 @@

17import QtQuick 2.4

18import QtTest 1.0

19+import Unity.Application 0.1

19import Ubuntu.Components 1.3

20import Ubuntu.Components 1.3

20import Unity.Test 0.1 as UT

21import Unity.Test 0.1 as UT

22+import Utils 0.1

22TestCase {

24TestCase {

23 id: testCase

25 id: testCase

24− TestUtil {id:util}

26+ property var util: TestUtil {id:util}

26 // This is needed for waitForRendering calls to return

28 // This is needed for waitForRendering calls to return

27 // if the watched element already got rendered

29 // if the watched element already got rendered

@@ -538,4 +540,20 @@ TestCase {

538 tryCompare(transition, "running", false, 2000);

540 tryCompare(transition, "running", false, 2000);

539 }

541 }

540 }

542 }

543+

544+ /*

545+ kill all (fake) running apps but unity8-dash, bringing Unity.Application back to its initial state

546+ */

547+ function killApps() {

548+ while (ApplicationManager.count > 1) {

549+ var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0

550+ var application = ApplicationManager.get(appIndex);

551+ ApplicationManager.stopApplication(application.appId);

552+ // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.

553+ // They won't be gone until those surface items are destroyed.

554+ tryCompareFunction(function() { return application.surfaceList.count }, 0);

555+ tryCompare(application, "state", ApplicationInfo.Stopped);

556+ }

557+ compare(ApplicationManager.count, 1);

558+ }

541}

559}