6008b1d · unity8 · git.iko.soy

plugins/WindowManager/TopLevelWindowModel.cpp+30−30

compare with xenial

unifiedsplit

@@ -198,6 +198,7 @@ void TopLevelWindowModel::prependSurface(unityapi::MirSurfaceInterface *surface,

198 ModelEntry &entry = m_windowModel[i];

199 if (entry.application == application && entry.window->surface() == nullptr) {

200 entry.window->setSurface(surface);

201+ m_allSurfaces.insert(surface);

201 connectSurface(surface);

202 connectSurface(surface);

202 INFO_MSG << " appId=" << application->appId() << " surface=" << surface

203 INFO_MSG << " appId=" << application->appId() << " surface=" << surface

203 << ", filling out placeholder. after: " << toString();

204 << ", filling out placeholder. after: " << toString();

@@ -224,8 +225,8 @@ void TopLevelWindowModel::prependSurfaceHelper(unityapi::MirSurfaceInterface *su

224 Window *window = createWindow(surface);

225 Window *window = createWindow(surface);

225

226

226 m_windowModel.prepend(ModelEntry(window, application));

227 m_windowModel.prepend(ModelEntry(window, application));

227− m_allSurfaces.insert(surface);

228 if (surface) {

229+ m_allSurfaces.insert(surface);

229 connectSurface(surface);

230 connectSurface(surface);

230 }

231 }

231

232

@@ -436,7 +437,7 @@ void TopLevelWindowModel::onSurfacesAboutToBeRemovedFromWorkspace(const std::sha

436 m_allSurfaces.remove(surface);

437 m_allSurfaces.remove(surface);

437 continue;

438 continue;

438 }

439 }

439− while(iter != surfaces.constEnd()) {

440+ while(iter != surfaces.constEnd()) {

440 int index = indexOf(*iter);

441 int index = indexOf(*iter);

441 if (index != end+1) {

442 if (index != end+1) {

442 break;

443 break;

@@ -459,7 +460,7 @@ void TopLevelWindowModel::onSurfacesAboutToBeRemovedFromWorkspace(const std::sha

459 window->setFocused(false);

460 window->setFocused(false);

460

461

461 m_windowModel.removeAt(start);

462 m_windowModel.removeAt(start);

462− m_allSurfaces.remove(window->surface());

463+ m_allSurfaces.remove(surface);

463 }

464 }

464

465

465 if (m_modelState == RemovingState) {

466 if (m_modelState == RemovingState) {

@@ -482,12 +483,13 @@ void TopLevelWindowModel::removeAt(int index)

482 }

483 }

483

484

484 auto window = m_windowModel[index].window;

485 auto window = m_windowModel[index].window;

486+ auto surface = window->surface();

485

487

486 window->setSurface(nullptr);

488 window->setSurface(nullptr);

487 window->setFocused(false);

489 window->setFocused(false);

488

490

489 m_windowModel.removeAt(index);

491 m_windowModel.removeAt(index);

490− m_allSurfaces.remove(window->surface());

492+ m_allSurfaces.remove(surface);

491

493

492 if (m_modelState == RemovingState) {

494 if (m_modelState == RemovingState) {

493 endRemoveRows();

495 endRemoveRows();

@@ -794,34 +796,32 @@ void TopLevelWindowModel::refreshWindows()

794 m_windowModel.clear();

796 m_windowModel.clear();

795 m_allSurfaces.clear();

797 m_allSurfaces.clear();

796

798

797− if (!m_workspace || !m_applicationManager) return;

799+ if (!m_workspace || !m_applicationManager || !m_surfaceManager) return;

798− WMPolicyInterface::instance()->forEachWindowInWorkspace(m_workspace->workspace(), [this](const miral::Window &window) {

800+

799− auto surface = m_surfaceManager->surfaceFor(window);

801+ m_surfaceManager->forEachSurfaceInWorkspace(m_workspace->workspace(), [this](unity::shell::application::MirSurfaceInterface* surface) {

800− if (surface) {

801− if (surface->parentSurface()) {

802+ if (surface->parentSurface()) {

802− // Wrap it in a Window so that we keep focusedWindow() up to date.

803+ // Wrap it in a Window so that we keep focusedWindow() up to date.

803− Window *window = createWindow(surface);

804+ Window *window = createWindow(surface);

804− connect(surface, &QObject::destroyed, window, [=](){

805+ connect(surface, &QObject::destroyed, window, [=](){

805− window->setSurface(nullptr);

806+ window->setSurface(nullptr);

806− window->deleteLater();

807+ window->deleteLater();

807− });

808+ });

809+ } else {

810+ if (surface->type() == Mir::InputMethodType) {

811+ setInputMethodWindow(createWindow(surface));

808 } else {

812 } else {

809− if (surface->type() == Mir::InputMethodType) {

813+ auto *application = m_applicationManager->findApplicationWithSurface(surface);

810− setInputMethodWindow(createWindow(surface));

814+ if (application) {

815+ prependSurface(surface, application);

811 } else {

816 } else {

812− auto *application = m_applicationManager->findApplicationWithSurface(surface);

813− if (application) {

814− prependSurface(surface, application);

815− } else {

816− // Must be a prompt session. No need to do add it as a prompt surface is not top-level.

817+ // Must be a prompt session. No need to do add it as a prompt surface is not top-level.

817− // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.

818+ // It will show up in the ApplicationInfoInterface::promptSurfaceList of some application.

818− // Still wrap it in a Window though, so that we keep focusedWindow() up to date.

819+ // Still wrap it in a Window though, so that we keep focusedWindow() up to date.

819− Window *promptWindow = createWindow(surface);

820+ Window *promptWindow = createWindow(surface);

820− connect(surface, &QObject::destroyed, promptWindow, [=](){

821+ connect(surface, &QObject::destroyed, promptWindow, [=](){

821− promptWindow->setSurface(nullptr);

822+ promptWindow->setSurface(nullptr);

822− promptWindow->deleteLater();

823+ promptWindow->deleteLater();

823− });

824+ });

824− }

825 }

826 }

827 }

plugins/WindowManager/Workspace.cpp−5

@@ -65,11 +65,6 @@ Workspace::~Workspace()

65 }

66}

67

68−void Workspace::moveWindowsTo(Workspace *workspace)

69−{

70− WMPolicyInterface::instance()->moveWorkspaceContentToWorkspace(workspace->m_workspace, m_workspace);

71−}

72−

73void Workspace::activate()

68void Workspace::activate()

74{

69{

75 WorkspaceManager::instance()->setActiveWorkspace(this);

70 WorkspaceManager::instance()->setActiveWorkspace(this);

plugins/WindowManager/Workspace.h−2

@@ -51,8 +51,6 @@ public:

51 virtual bool isActive() const { return m_active; }

52 bool isAssigned() const;

53

54− void moveWindowsTo(Workspace* workspace);

55−

56 std::shared_ptr<miral::Workspace> workspace() const { return m_workspace; }

54 std::shared_ptr<miral::Workspace> workspace() const { return m_workspace; }

57

55

58

56

plugins/WindowManager/WorkspaceManager.cpp+25−1

@@ -17,6 +17,7 @@

17#include "WorkspaceManager.h"

18#include "Workspace.h"

19#include "TopLevelWindowModel.h"

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

20

21

21// Qt

22// Qt

22#include <QGuiApplication>

23#include <QGuiApplication>

@@ -31,6 +32,7 @@ WorkspaceManager *WorkspaceManager::instance()

31

32

32WorkspaceManager::WorkspaceManager()

33WorkspaceManager::WorkspaceManager()

33 : m_activeWorkspace(nullptr)

34 : m_activeWorkspace(nullptr)

35+ , m_surfaceManager(nullptr)

34{

36{

35}

37}

36

38

@@ -77,7 +79,7 @@ void WorkspaceManager::destroyWorkspace(Workspace *workspace)

77 setActiveWorkspace(m_allWorkspaces.count() ? *m_allWorkspaces.begin() : nullptr);

79 setActiveWorkspace(m_allWorkspaces.count() ? *m_allWorkspaces.begin() : nullptr);

78 }

80 }

79 if (m_activeWorkspace) {

81 if (m_activeWorkspace) {

80− workspace->moveWindowsTo(m_activeWorkspace);

82+ moveWorkspaceContentToWorkspace(workspace, m_activeWorkspace);

81 }

83 }

82

84

83 disconnect(workspace, 0, this, 0);

85 disconnect(workspace, 0, this, 0);

@@ -97,6 +99,28 @@ void WorkspaceManager::destroyFloatingWorkspaces()

97 }

99 }

98}

100}

99

101

102+void WorkspaceManager::setSurfaceManager(unity::shell::application::SurfaceManagerInterface *surfaceManager)

103+{

104+ if (m_surfaceManager == surfaceManager) return;

105+

106+ m_surfaceManager = surfaceManager;

107+ Q_EMIT surfaceManagerChanged();

108+}

109+

110+void WorkspaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface *surface, Workspace *workspace)

111+{

112+ if (m_surfaceManager) {

113+ m_surfaceManager->moveSurfaceToWorkspace(surface, workspace->workspace());

114+ }

115+}

116+

117+void WorkspaceManager::moveWorkspaceContentToWorkspace(Workspace *from, Workspace *to)

118+{

119+ if (m_surfaceManager) {

120+ m_surfaceManager->moveWorkspaceContentToWorkspace(from->workspace(), to->workspace());

121+ }

122+}

123+

100Workspace *WorkspaceManager::activeWorkspace() const

124Workspace *WorkspaceManager::activeWorkspace() const

101{

125{

102 return m_activeWorkspace;

126 return m_activeWorkspace;

plugins/WindowManager/WorkspaceManager.h+24−1

@@ -23,11 +23,24 @@

23class Workspace;

24class ScreensProxy;

25

26+namespace unity {

27+ namespace shell {

28+ namespace application {

29+ class MirSurfaceInterface;

30+ class SurfaceManagerInterface;

31+ }

32+ }

33+}

34+

26class WorkspaceManager : public QObject

35class WorkspaceManager : public QObject

27{

36{

28 Q_OBJECT

37 Q_OBJECT

29 Q_PROPERTY(Workspace* activeWorkspace READ activeWorkspace WRITE setActiveWorkspace2 NOTIFY activeWorkspaceChanged)

38 Q_PROPERTY(Workspace* activeWorkspace READ activeWorkspace WRITE setActiveWorkspace2 NOTIFY activeWorkspaceChanged)

30− Q_PROPERTY(QQmlListProperty<Workspace> floatingWorkspaces READ floatingWorkspaces NOTIFY floatingWorkspacesChanged)

39+

40+ Q_PROPERTY(unity::shell::application::SurfaceManagerInterface* surfaceManager

41+ READ surfaceManager

42+ WRITE setSurfaceManager

43+ NOTIFY surfaceManagerChanged)

31

44

32public:

45public:

33 static WorkspaceManager* instance();

46 static WorkspaceManager* instance();

@@ -41,9 +54,18 @@ public:

41 QQmlListProperty<Workspace> floatingWorkspaces();

54 QQmlListProperty<Workspace> floatingWorkspaces();

42 void destroyFloatingWorkspaces();

55 void destroyFloatingWorkspaces();

43

56

57+ unity::shell::application::SurfaceManagerInterface *surfaceManager() const { return m_surfaceManager; }

58+ void setSurfaceManager(unity::shell::application::SurfaceManagerInterface*);

59+

60+ Q_INVOKABLE void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

61+ Workspace* workspace);

62+

63+ Q_INVOKABLE void moveWorkspaceContentToWorkspace(Workspace* from, Workspace* to);

64+

44Q_SIGNALS:

65Q_SIGNALS:

45 void activeWorkspaceChanged();

66 void activeWorkspaceChanged();

46 void floatingWorkspacesChanged();

67 void floatingWorkspacesChanged();

68+ void surfaceManagerChanged();

47

69

48private:

70private:

49 WorkspaceManager();

71 WorkspaceManager();

@@ -53,6 +75,7 @@ private:

53 QSet<Workspace*> m_allWorkspaces;

75 QSet<Workspace*> m_allWorkspaces;

54 QList<Workspace*> m_floatingWorkspaces;

76 QList<Workspace*> m_floatingWorkspaces;

55 Workspace* m_activeWorkspace;

77 Workspace* m_activeWorkspace;

78+ unity::shell::application::SurfaceManagerInterface* m_surfaceManager;

56};

79};

57

80

58#endif // WORKSPACEMANAGER_H

81#endif // WORKSPACEMANAGER_H

src/WindowManagementPolicy.cpp+4−13

@@ -33,8 +33,9 @@ void WindowManagementPolicy::advise_new_window(miral::WindowInfo const& window_i

33 auto const parent = window_info.parent();

34

35 auto activeWorkspace = m_activeWorkspace.lock();

36− if (!parent && activeWorkspace)

36+ if (!parent && activeWorkspace) {

37 tools.add_tree_to_workspace(window_info.window(), activeWorkspace);

38+ }

38}

39}

39

40

40std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

41std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

@@ -43,7 +44,7 @@ std::shared_ptr<miral::Workspace> WindowManagementPolicy::createWorkspace()

43 m_workspaces.insert(workspace);

44 m_workspaces.insert(workspace);

44

45

45 if (m_activeWorkspace.lock() == m_dummyWorkspace) {

46 if (m_activeWorkspace.lock() == m_dummyWorkspace) {

46− moveWorkspaceContentToWorkspace(workspace, m_dummyWorkspace);

47+ tools.move_workspace_content_to_workspace(workspace, m_dummyWorkspace);

47 m_activeWorkspace = workspace;

48 m_activeWorkspace = workspace;

48 }

49 }

49 return workspace;

50 return workspace;

@@ -56,20 +57,10 @@ void WindowManagementPolicy::releaseWorkspace(const std::shared_ptr<miral::Works

56

57

57 if (m_workspaces.size() == 0) {

58 if (m_workspaces.size() == 0) {

58 m_activeWorkspace = m_dummyWorkspace;

59 m_activeWorkspace = m_dummyWorkspace;

59− moveWorkspaceContentToWorkspace(m_dummyWorkspace, workspace);

60+ tools.move_workspace_content_to_workspace(m_dummyWorkspace, workspace);

60 }

61 }

61}

62}

62

63

63−void WindowManagementPolicy::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void (const miral::Window &)> &callback)

64−{

65− tools.for_each_window_in_workspace(workspace, callback);

66−}

67−

68−void WindowManagementPolicy::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &toWorkspace, const std::shared_ptr<miral::Workspace> &fromWorkspace)

69−{

70− tools.move_workspace_content_to_workspace(toWorkspace, fromWorkspace);

71−}

72−

73void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

64void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

74{

65{

75 if (m_activeWorkspace.lock() == workspace)

66 if (m_activeWorkspace.lock() == workspace)

src/WindowManagementPolicy.h−7

@@ -35,13 +35,6 @@ public:

35

36 void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) override;

37

38− void forEachWindowInWorkspace(

39− std::shared_ptr<miral::Workspace> const& workspace,

40− std::function<void(miral::Window const& window)> const& callback) override;

41−

42− void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &toWorkspace,

43− const std::shared_ptr<miral::Workspace> &fromWorkspace) override;

44−

45 void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

38 void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

46

39

47private:

40private:

src/libunity8-private/wmpolicyinterface.h−7

@@ -36,13 +36,6 @@ public:

36

37 virtual void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace) = 0;

38

39− virtual void forEachWindowInWorkspace(

40− std::shared_ptr<miral::Workspace> const& workspace,

41− std::function<void(miral::Window const& window)> const& callback) = 0;

42−

43− virtual void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &toWorkspace,

44− const std::shared_ptr<miral::Workspace> &fromWorkspace) = 0;

45−

46 virtual void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) = 0;

39 virtual void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) = 0;

47};

40};

48

41

tests/mocks/Unity/Application/SurfaceManager.cpp+42−9

@@ -60,12 +60,12 @@ SurfaceManager::SurfaceManager(QObject *)

60

61 connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowsAddedToWorkspace,

62 this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {

63− Q_EMIT surfacesAddedToWorkspace(workspace, find(windows));

63+ Q_EMIT surfacesAddedToWorkspace(workspace, surfacesFor(windows));

64 });

65

66 connect(WindowManagementPolicy::instance(), &WindowManagementPolicy::windowsAboutToBeRemovedFromWorkspace,

67 this, [this](const std::shared_ptr<miral::Workspace> &workspace, const std::vector<miral::Window> &windows) {

68− Q_EMIT surfacesAboutToBeRemovedFromWorkspace(workspace, find(windows));

68+ Q_EMIT surfacesAboutToBeRemovedFromWorkspace(workspace, surfacesFor(windows));

69 });

70}

71

@@ -81,9 +81,16 @@ SurfaceManager::~SurfaceManager()

81 m_instance = nullptr;

82}

83

84+MirSurfaceInterface *SurfaceManager::surfaceFor(const miral::Window& window) const

85+{

86+ auto iter = m_windowToSurface.find({window});

87+ if (iter != m_windowToSurface.end()) {

88+ return *iter;

89+ }

90+ return nullptr;

91+}

84

92

85−

86−QVector<MirSurfaceInterface*> SurfaceManager::find(const std::vector<miral::Window> &windows) const

93+QVector<MirSurfaceInterface*> SurfaceManager::surfacesFor(const std::vector<miral::Window> &windows) const

87{

94{

88 QVector<unityapi::MirSurfaceInterface*> surfaces;

95 QVector<unityapi::MirSurfaceInterface*> surfaces;

89 for (size_t i = 0; i < windows.size(); i++) {

96 for (size_t i = 0; i < windows.size(); i++) {

@@ -95,13 +102,13 @@ QVector<MirSurfaceInterface*> SurfaceManager::find(const std::vector<miral::Wind

95 return surfaces;

102 return surfaces;

96}

103}

97

104

98−MirSurfaceInterface *SurfaceManager::surfaceFor(const miral::Window& window) const

105+miral::Window SurfaceManager::windowFor(MirSurfaceInterface *surface) const

99{

106{

100− auto iter = m_windowToSurface.find({window});

107+ auto iter = m_surfaceToWindow.find(surface);

101− if (iter != m_windowToSurface.end()) {

108+ if (iter != m_surfaceToWindow.end()) {

102− return *iter;

109+ return iter->window;

103 }

110 }

104− return nullptr;

111+ return miral::Window();

105}

112}

106

113

107MirSurface *SurfaceManager::createSurface(const QString& name,

114MirSurface *SurfaceManager::createSurface(const QString& name,

@@ -267,6 +274,32 @@ void SurfaceManager::activate(unityapi::MirSurfaceInterface *apiSurface)

267 DEBUG_MSG("("<<surface<<") ended");

274 DEBUG_MSG("("<<surface<<") ended");

268}

275}

269

276

277+void SurfaceManager::forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

278+ const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback)

279+{

280+ WindowManagementPolicy::instance()->forEachWindowInWorkspace(workspace, [&](const miral::Window &window) {

281+ auto surface = surfaceFor(window);

282+ if (surface) {

283+ callback(surface);

284+ }

285+ });

286+}

287+

288+void SurfaceManager::moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

289+ const std::shared_ptr<miral::Workspace> &workspace)

290+{

291+ auto window = windowFor(surface);

292+ if (window) {

293+ WindowManagementPolicy::instance()->moveWindowToWorkspace(window, workspace);

294+ }

295+}

296+

297+void SurfaceManager::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

298+ const std::shared_ptr<miral::Workspace> &from)

299+{

300+ WindowManagementPolicy::instance()->moveWorkspaceContentToWorkspace(to, from);

301+}

302+

270void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

303void SurfaceManager::onStateRequested(MirSurface *surface, Mir::State state)

271{

304{

272 DEBUG_MSG("("<<surface<<","<<state<<") started");

305 DEBUG_MSG("("<<surface<<","<<state<<") started");

tests/mocks/Unity/Application/SurfaceManager.h+10−3

@@ -50,12 +50,17 @@ public:

50

51 static SurfaceManager *instance();

52

53− unity::shell::application::MirSurfaceInterface *surfaceFor(const miral::Window& window) const override;

54−

55 // SurfaceManagerInterface

53 // SurfaceManagerInterface

56 void raise(unity::shell::application::MirSurfaceInterface *surface) override;

54 void raise(unity::shell::application::MirSurfaceInterface *surface) override;

57 void activate(unity::shell::application::MirSurfaceInterface *surface) override;

55 void activate(unity::shell::application::MirSurfaceInterface *surface) override;

58

56

57+ void forEachSurfaceInWorkspace(const std::shared_ptr<miral::Workspace> &workspace,

58+ const std::function<void(unity::shell::application::MirSurfaceInterface*)> &callback) override;

59+ void moveSurfaceToWorkspace(unity::shell::application::MirSurfaceInterface* surface,

60+ const std::shared_ptr<miral::Workspace> &workspace) override;

61+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to,

62+ const std::shared_ptr<miral::Workspace> &from) override;

63+

59 Q_INVOKABLE MirSurface* createSurface(const QString& name,

64 Q_INVOKABLE MirSurface* createSurface(const QString& name,

60 Mir::Type type,

65 Mir::Type type,

61 Mir::State state,

66 Mir::State state,

@@ -105,7 +110,9 @@ private:

105 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

110 void doRaise(unity::shell::application::MirSurfaceInterface *surface);

106 void focusFirstAvailableSurface();

111 void focusFirstAvailableSurface();

107 void registerSurface(MirSurface *surface);

112 void registerSurface(MirSurface *surface);

113+ unity::shell::application::MirSurfaceInterface* surfaceFor(const miral::Window &window) const;

108− QVector<unity::shell::application::MirSurfaceInterface*> find(const std::vector<miral::Window> &windows) const;

114+ QVector<unity::shell::application::MirSurfaceInterface*> surfacesFor(const std::vector<miral::Window> &windows) const;

115+ miral::Window windowFor(unity::shell::application::MirSurfaceInterface* surface) const;

109

116

110 static SurfaceManager *m_instance;

117 static SurfaceManager *m_instance;

111

118

tests/mocks/WindowManager/WindowManagementPolicy.cpp+39−26

@@ -54,48 +54,61 @@ void WindowManagementPolicy::releaseWorkspace(const std::shared_ptr<miral::Works

54 }

55}

56

57−void WindowManagementPolicy::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void (const miral::Window &)> &callback)

57+void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

58{

59+ if (m_activeWorkspace.lock() == workspace)

60+ return;

61+ m_activeWorkspace = workspace ? workspace : m_dummyWorkspace;

62+}

63+

64+void WindowManagementPolicy::addWindow(const miral::Window &window)

65+{

66+ Q_EMIT windowAdded(window);

67+

68+ auto activeWorkspace = m_activeWorkspace.lock();

69+ if (activeWorkspace) {

70+ m_windows.insert(activeWorkspace, window);

71+

72+ Q_EMIT windowsAddedToWorkspace(activeWorkspace, {window});

73+ }

74+}

75+

76+void WindowManagementPolicy::forEachWindowInWorkspace(const std::shared_ptr<miral::Workspace> &workspace, const std::function<void(const miral::Window &)> &callback)

77+{

59− QMultiMap<miral::Workspace*, miral::Window>::iterator i = m_windows.find(workspace.get());

78+ WorkspaceWindows::iterator i = m_windows.find(workspace);

60− while (i != m_windows.end() && i.key() == workspace.get()) {

79+ while (i != m_windows.end() && i.key() == workspace) {

61 callback(i.value());

80 callback(i.value());

62 ++i;

81 ++i;

63 }

82 }

64}

83}

65

84

85+void WindowManagementPolicy::moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace)

86+{

87+ auto from = m_windows.key(window);

88+ if (from) {

89+ auto iter = m_windows.find(from, window);

90+ Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, { window });

91+ m_windows.erase(iter);

92+ }

93+

94+ m_windows.insert(workspace, window);

95+ Q_EMIT windowsAddedToWorkspace(workspace, { window });

96+}

97+

66void WindowManagementPolicy::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to, const std::shared_ptr<miral::Workspace> &from)

98void WindowManagementPolicy::moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace> &to, const std::shared_ptr<miral::Workspace> &from)

67{

99{

68 std::vector<miral::Window> windows;

100 std::vector<miral::Window> windows;

69

101

70− QMultiMap<miral::Workspace*, miral::Window>::iterator i = m_windows.find(from.get());

102+ WorkspaceWindows::iterator i = m_windows.find(from);

71− while (i != m_windows.end() && i.key() == from.get()) {

103+ while (i != m_windows.end() && i.key() == from) {

72 windows.push_back(i.value());

104 windows.push_back(i.value());

73 ++i;

105 ++i;

74 }

106 }

75 Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, windows);

107 Q_EMIT windowsAboutToBeRemovedFromWorkspace(from, windows);

76− m_windows.remove(from.get());

108+ m_windows.remove(from);

77

109

78 Q_FOREACH(miral::Window window, windows) {

110 Q_FOREACH(miral::Window window, windows) {

79− m_windows.insert(to.get(), window);

111+ m_windows.insert(to, window);

80 }

112 }

81 Q_EMIT windowsAddedToWorkspace(to, windows);

113 Q_EMIT windowsAddedToWorkspace(to, windows);

82}

114}

83−

84−void WindowManagementPolicy::addWindow(const miral::Window &window)

85−{

86− Q_EMIT windowAdded(window);

87−

88− auto activeWorkspace = m_activeWorkspace.lock();

89− if (activeWorkspace) {

90− m_windows.insert(activeWorkspace.get(), window);

91−

92− Q_EMIT windowsAddedToWorkspace(activeWorkspace, {window});

93− }

94−}

95−

96−void WindowManagementPolicy::setActiveWorkspace(const std::shared_ptr<miral::Workspace> &workspace)

97−{

98− if (m_activeWorkspace.lock() == workspace)

99− return;

100− m_activeWorkspace = workspace ? workspace : m_dummyWorkspace;

101−}

tests/mocks/WindowManager/WindowManagementPolicy.h+9−8

@@ -44,18 +44,18 @@ public:

44

45 // From WMPolicyInterface

46 std::shared_ptr<miral::Workspace> createWorkspace() override;

47−

48 void releaseWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

47 void releaseWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

48+ void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

49

50− void forEachWindowInWorkspace(std::shared_ptr<miral::Workspace> const& workspace,

50+ void addWindow(const miral::Window& window);

51− std::function<void(miral::Window const&)> const& callback) override;

52

51

53− void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace>& to,

52+ void forEachWindowInWorkspace(std::shared_ptr<miral::Workspace> const& workspace,

54− const std::shared_ptr<miral::Workspace>& from) override;

53+ std::function<void(miral::Window const&)> const& callback);

55

54

56− void setActiveWorkspace(const std::shared_ptr<miral::Workspace>& workspace) override;

55+ void moveWindowToWorkspace(const miral::Window &window, const std::shared_ptr<miral::Workspace> &workspace);

57

56

58− void addWindow(const miral::Window& window);

57+ void moveWorkspaceContentToWorkspace(const std::shared_ptr<miral::Workspace>& to,

58+ const std::shared_ptr<miral::Workspace>& from);

59

60Q_SIGNALS:

61 void windowAdded(const miral::Window& window);

@@ -67,6 +67,7 @@ private:

67 std::shared_ptr<miral::Workspace> m_dummyWorkspace;

68 std::unordered_set<std::shared_ptr<miral::Workspace>> m_workspaces;

69

70− QMultiMap<miral::Workspace*, miral::Window> m_windows;

70+ typedef QMultiMap<std::shared_ptr<miral::Workspace>, miral::Window> WorkspaceWindows;

71+ WorkspaceWindows m_windows;

71};

72};

72#endif // UNITY_WINDOWMANAGEMENTPOLICY_H

73#endif // UNITY_WINDOWMANAGEMENTPOLICY_H