27b74cd · unity8 · git.iko.soy

plugins/WindowManager/Screens.cpp−4

compare with xenial

unifiedsplit

@@ -29,10 +29,6 @@

29Screens::Screens(const QSharedPointer<qtmir::Screens>& model)

30 : m_wrapped(model)

31{

32− if (qGuiApp->platformName() != QLatin1String("mirserver")) {

33− qCritical("Not using 'mirserver' QPA plugin. Using qGuiApp may produce unknown results.");

34− }

35−

36 connect(m_wrapped.data(), &qtmir::Screens::screenAdded, this, &Screens::onScreenAdded);

32 connect(m_wrapped.data(), &qtmir::Screens::screenAdded, this, &Screens::onScreenAdded);

37 connect(m_wrapped.data(), &qtmir::Screens::screenRemoved, this, &Screens::onScreenRemoved);

33 connect(m_wrapped.data(), &qtmir::Screens::screenRemoved, this, &Screens::onScreenRemoved);

38 connect(m_wrapped.data(), &qtmir::Screens::activeScreenChanged, this, &Screens::activeScreenChanged);

34 connect(m_wrapped.data(), &qtmir::Screens::activeScreenChanged, this, &Screens::activeScreenChanged);

plugins/WindowManager/TopLevelWindowModel.cpp+2−2

@@ -29,7 +29,7 @@

29// local

30#include "Window.h"

31#include "Workspace.h"

32−#include "windowmanagementpolicy.h"

32+#include "wmpolicyinterface.h"

33

34// qtmir

35#include <qtmir/mirserverapplication.h>

@@ -831,7 +831,7 @@ void TopLevelWindowModel::refreshWindows()

831 m_allSurfaces.clear();

832

833 if (!m_workspace || !m_applicationManager) return;

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

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

835 auto surface = m_surfaceManager->surfaceFor(window);

836 if (surface) {

837 if (surface->parentSurface()) {

plugins/WindowManager/Workspace.cpp+5−5

@@ -19,13 +19,13 @@

19#include "WorkspaceManager.h"

20#include "TopLevelWindowModel.h"

21

22−#include "windowmanagementpolicy.h"

22+#include "wmpolicyinterface.h"

23

24int nextWorkspace = 0;

25

26Workspace::Workspace(QObject *parent)

27 : QObject(parent)

28− , m_workspace(WindowManagementPolicy::instance()->createWorkspace())

28+ , m_workspace(WMPolicyInterface::instance()->createWorkspace())

29 , m_model(nullptr)

30 , m_active(false)

31{

@@ -38,7 +38,7 @@ Workspace::Workspace(QObject *parent)

38 Q_EMIT activeChanged(m_active);

39

40 if (m_active) {

41− WindowManagementPolicy::instance()->setActiveWorkspace(m_workspace);

41+ WMPolicyInterface::instance()->setActiveWorkspace(m_workspace);

42 }

43 }

44 });

@@ -67,7 +67,7 @@ Workspace::~Workspace()

67

68void Workspace::moveWindowsTo(Workspace *workspace)

69{

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

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

71}

72

73void Workspace::activate()

@@ -110,7 +110,7 @@ void Workspace::unassign()

110

111void Workspace::release()

112{

113− WindowManagementPolicy::instance()->releaseWorkspace(m_workspace);

113+ WMPolicyInterface::instance()->releaseWorkspace(m_workspace);

114 deleteLater();

115}

116

src/CMakeLists.txt+1

@@ -32,6 +32,7 @@ set(SOURCE_FILES

32 UnityCommandLineParser.cpp

33 UnixSignalHandler.cpp

34 DebuggingController.cpp

35+ WindowManagementPolicy.cpp

35 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

36 ${QML_FILES} # This is to make qml and image files appear in the IDE's project tree

36)

37)

37

38

src/UnityApplication.cpp+1−1

@@ -32,7 +32,7 @@

32#include "CachingNetworkManagerFactory.h"

33#include "UnityCommandLineParser.h"

34#include "DebuggingController.h"

35−#include "windowmanagementpolicy.h"

35+#include "WindowManagementPolicy.h"

36

37#include <QDebug>

38

src/libunity8-private/windowmanagementpolicy.cpp → src/WindowManagementPolicy.cpprenamed+2−11

@@ -14,27 +14,18 @@

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

15 */

16

17−#include "windowmanagementpolicy.h"

17+#include "WindowManagementPolicy.h"

18−

19−#include <QDebug>

20−

21−WindowManagementPolicy* WindowManagementPolicy::m_self = nullptr;

22

18

23WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate &dd)

19WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate &dd)

24 : qtmir::WindowManagementPolicy(tools, dd)

20 : qtmir::WindowManagementPolicy(tools, dd)

25 , m_dummyWorkspace(this->tools.create_workspace())

21 , m_dummyWorkspace(this->tools.create_workspace())

26{

22{

27− m_self = this;

23+ wmPolicyInterface = this;

28

24

29 // we must always have a active workspace.

25 // we must always have a active workspace.

30 m_activeWorkspace = m_dummyWorkspace;

26 m_activeWorkspace = m_dummyWorkspace;

31}

27}

32

28

33−WindowManagementPolicy *WindowManagementPolicy::instance()

34−{

35− return m_self;

36−}

37−

38void WindowManagementPolicy::advise_new_window(miral::WindowInfo const& window_info)

29void WindowManagementPolicy::advise_new_window(miral::WindowInfo const& window_info)

39{

30{

40 qtmir::WindowManagementPolicy::advise_new_window(window_info);

31 qtmir::WindowManagementPolicy::advise_new_window(window_info);

src/libunity8-private/windowmanagementpolicy.h → src/WindowManagementPolicy.hrenamed+10−9

@@ -18,32 +18,33 @@

18#define UNITY_WINDOWMANAGEMENTPOLICY_H

19

20#include <qtmir/windowmanagementpolicy.h>

21+#include "wmpolicyinterface.h"

21

22

22#include <unordered_set>

23#include <unordered_set>

23

24

24−class Q_DECL_EXPORT WindowManagementPolicy : public qtmir::WindowManagementPolicy

25+class Q_DECL_EXPORT WindowManagementPolicy : public qtmir::WindowManagementPolicy,

26+ public WMPolicyInterface

25{

27{

26public:

28public:

27 WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate& dd);

29 WindowManagementPolicy(const miral::WindowManagerTools &tools, qtmir::WindowManagementPolicyPrivate& dd);

28

30

29− static WindowManagementPolicy *instance();

30−

31 void advise_new_window(miral::WindowInfo const& window_info) override;

32

33+ // From WMPolicyInterface

33− std::shared_ptr<miral::Workspace> createWorkspace();

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

35+

34− void releaseWorkspace(const std::shared_ptr<miral::Workspace> &workspace);

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

35

37

36 void forEachWindowInWorkspace(

38 void forEachWindowInWorkspace(

37 std::shared_ptr<miral::Workspace> const& workspace,

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

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

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

39

41

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

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

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

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

42

44

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

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

44

46

45private:

47private:

46− static WindowManagementPolicy* m_self;

47 std::weak_ptr<miral::Workspace> m_activeWorkspace;

48 std::weak_ptr<miral::Workspace> m_activeWorkspace;

48

49

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

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

src/libunity8-private/CMakeLists.txt+1−10

@@ -4,26 +4,17 @@ set(VERSION ${SOVERSION}.0.0)

4

5project(lib${LIB_NAME})

6

7−include_directories(

8− SYSTEM

9− ${QTMIRSERVER_INCLUDE_DIRS}

10−)

11−

12set(lib${LIB_NAME}_SRCS

7set(lib${LIB_NAME}_SRCS

13 abstractdbusservicemonitor.cpp

8 abstractdbusservicemonitor.cpp

14 unitydbusobject.cpp

9 unitydbusobject.cpp

15 unitydbusvirtualobject.cpp

10 unitydbusvirtualobject.cpp

16− windowmanagementpolicy.cpp

11+ wmpolicyinterface.cpp

17 )

12 )

18

13

19add_library(${LIB_NAME} SHARED

14add_library(${LIB_NAME} SHARED

20 ${lib${LIB_NAME}_SRCS}

15 ${lib${LIB_NAME}_SRCS}

21 )

16 )

22

17

23−target_link_libraries(${LIB_NAME}

24− ${QTMIRSERVER_LDFLAGS}

25− )

26−

27set_target_properties(${LIB_NAME} PROPERTIES

18set_target_properties(${LIB_NAME} PROPERTIES

28 VERSION ${VERSION}

19 VERSION ${VERSION}

29 SOVERSION ${SOVERSION}

20 SOVERSION ${SOVERSION}

src/libunity8-private/wmpolicyinterface.cppnew file+24

@@ -0,0 +1,24 @@

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 "wmpolicyinterface.h"

18+

19+WMPolicyInterface* wmPolicyInterface = nullptr;

20+

21+WMPolicyInterface *WMPolicyInterface::instance()

22+{

23+ return wmPolicyInterface;

24+}

src/libunity8-private/wmpolicyinterface.hnew file+51

@@ -0,0 +1,51 @@

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 WMPOLICYINTERFACE_H

18+#define WMPOLICYINTERFACE_H

19+

20+#include <memory>

21+#include <functional>

22+

23+#include <qglobal.h>

24+

25+namespace miral {

26+class Workspace;

27+class Window;

28+}

29+

30+class Q_DECL_EXPORT WMPolicyInterface

31+{

32+public:

33+ static WMPolicyInterface *instance();

34+

35+ virtual std::shared_ptr<miral::Workspace> createWorkspace() = 0;

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;

47+};

48+

49+extern Q_DECL_EXPORT WMPolicyInterface* wmPolicyInterface;

50+

51+#endif // WMPOLICYINTERFACE_H

tests/mocks/Unity/Application/CMakeLists.txt+1

@@ -4,6 +4,7 @@ include_directories(

4 SYSTEM

5 ${MIRTEST_INCLUDE_DIRS}

6 ${MIRAL_INCLUDE_DIRS}

7+ ${libunity8-private_SOURCE_DIR}

7)

8)

8

9

9set(FakeUnityApplicationQml_SOURCES

10set(FakeUnityApplicationQml_SOURCES

tests/mocks/Unity/Application/SurfaceManager.cpp+1−1

@@ -18,7 +18,7 @@

18

19#include "ApplicationInfo.h"

20#include "VirtualKeyboard.h"

21−#include "../../WindowManager/windowmanagementpolicy.h"

21+#include "../../WindowManager/WindowManagementPolicy.h"

22

23#include <paths.h>

24#include <mirtest/mir/test/doubles/stub_surface.h>

tests/mocks/WindowManager/CMakeLists.txt+3−1

@@ -7,13 +7,15 @@ include_directories(

7 ${CMAKE_CURRENT_SOURCE_DIR}

8 ${CMAKE_CURRENT_BINARY_DIR}

9 ${CMAKE_SOURCE_DIR}/plugins/WindowManager

10+ ${libunity8-private_SOURCE_DIR}

10)

11)

11

12

12add_library(mockwindowmanagmentpolicy SHARED

13add_library(mockwindowmanagmentpolicy SHARED

13− windowmanagementpolicy.cpp

14+ WindowManagementPolicy.cpp

14)

15)

15target_link_libraries(mockwindowmanagmentpolicy

16target_link_libraries(mockwindowmanagmentpolicy

16 ${MIRAL_LDFLAGS}

17 ${MIRAL_LDFLAGS}

18+ unity8-private

17)

19)

18qt5_use_modules(mockwindowmanagmentpolicy Core)

20qt5_use_modules(mockwindowmanagmentpolicy Core)

19

21

tests/mocks/WindowManager/windowmanagementpolicy.cpp → tests/mocks/WindowManager/WindowManagementPolicy.cpprenamed+9−6

@@ -14,20 +14,23 @@

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

15 */

16

17−#include "windowmanagementpolicy.h"

17+#include "WindowManagementPolicy.h"

18

19−WindowManagementPolicy *WindowManagementPolicy::instance()

19+#include <QDebug>

20−{

21− static WindowManagementPolicy* inst(new WindowManagementPolicy());

22− return inst;

23−}

24

20

25WindowManagementPolicy::WindowManagementPolicy()

21WindowManagementPolicy::WindowManagementPolicy()

26 : m_dummyWorkspace(std::shared_ptr<miral::Workspace>())

22 : m_dummyWorkspace(std::shared_ptr<miral::Workspace>())

27{

23{

24+ wmPolicyInterface = this;

28 m_activeWorkspace = m_dummyWorkspace;

25 m_activeWorkspace = m_dummyWorkspace;

29}

26}

30

27

28+WindowManagementPolicy *WindowManagementPolicy::instance()

29+{

30+ static WindowManagementPolicy* wmPolicy(new WindowManagementPolicy);

31+ return wmPolicy;

32+}

33+

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

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

32{

35{

33 auto workspace = std::make_shared<miral::Workspace>();

36 auto workspace = std::make_shared<miral::Workspace>();

tests/mocks/WindowManager/windowmanagementpolicy.h → tests/mocks/WindowManager/WindowManagementPolicy.hrenamed+13−7

@@ -17,6 +17,8 @@

17#ifndef MOCKWINDOMANAGEMENTPOLICY_H

18#define MOCKWINDOMANAGEMENTPOLICY_H

19

20+#include "wmpolicyinterface.h"

21+

20#include <QObject>

22#include <QObject>

21#include <QMultiMap>

23#include <QMultiMap>

22#include <QVector>

24#include <QVector>

@@ -30,26 +32,30 @@ class Workspace {};

30}

32}

31

33

32// A Fake window management policy for the mock.

34// A Fake window management policy for the mock.

33−class Q_DECL_EXPORT WindowManagementPolicy : public QObject

35+class Q_DECL_EXPORT WindowManagementPolicy : public QObject,

36+ public WMPolicyInterface

34{

37{

35 Q_OBJECT

38 Q_OBJECT

36public:

39public:

37 WindowManagementPolicy();

40 WindowManagementPolicy();

38

41

42+ // for use in mocks

39 static WindowManagementPolicy *instance();

43 static WindowManagementPolicy *instance();

40

44

45+ // From WMPolicyInterface

41− std::shared_ptr<miral::Workspace> createWorkspace();

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

47+

42− void releaseWorkspace(const std::shared_ptr<miral::Workspace>& workspace);

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

43

49

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

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

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

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

46

52

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

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

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

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

49

55

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

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

51

57

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

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

53

59

54Q_SIGNALS:

60Q_SIGNALS:

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

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

tests/mocks/WindowManager/WindowManagerPlugin.cpp+9

@@ -25,6 +25,7 @@

25#include "WorkspaceManager.h"

26#include "Workspace.h"

27#include "WorkspaceModel.h"

28+#include "WindowManagementPolicy.h"

28

29

29#include <QtQml>

30#include <QtQml>

30

31

@@ -60,3 +61,11 @@ void WindowManagerPlugin::registerTypes(const char *uri)

60 qmlRegisterType<ScreenWindow>(uri, 1, 0, "ScreenWindow");

61 qmlRegisterType<ScreenWindow>(uri, 1, 0, "ScreenWindow");

61 qmlRegisterRevision<QWindow,1>(uri, 1, 0);

62 qmlRegisterRevision<QWindow,1>(uri, 1, 0);

62}

63}

64+

65+void WindowManagerPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

66+{

67+ QQmlExtensionPlugin::initializeEngine(engine, uri);

68+

69+ // Make sure we've initialized the wm policy.

70+ WindowManagementPolicy::instance();

71+}

tests/mocks/WindowManager/WindowManagerPlugin.h+1

@@ -27,6 +27,7 @@ class WindowManagerPlugin : public QQmlExtensionPlugin

27

28public:

29 void registerTypes(const char *uri) override;

30+ void initializeEngine(QQmlEngine *engine, const char *uri) override;

30};

31};

31

32

32#endif // WINDOWMANAGER_PLUGIN_H

33#endif // WINDOWMANAGER_PLUGIN_H