7af764c · unity8 · git.iko.soy

qml/Stages/SurfaceContainer.qml−17

compare with xenial

unifiedsplit

@@ -21,7 +21,6 @@ Item {

21 id: root

22 objectName: "surfaceContainer"

23 property Item surface: null

24− property var childSurfaces: surface ? surface.childSurfaces : 0

25

24

26 onSurfaceChanged: {

25 onSurfaceChanged: {

27 if (surface) {

26 if (surface) {

@@ -40,20 +39,4 @@ Item {

40 surface.release();

39 surface.release();

41 }

40 }

42 }

41 }

43−

44− Repeater {

45− model: root.childSurfaces

46−

47− delegate: Loader {

48− objectName: "childDelegate" + index

49− anchors.fill: root

50− z: 2

51−

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

53− source: Qt.resolvedUrl("SurfaceContainer.qml")

54− onLoaded: {

55− item.surface = modelData;

56− }

57− }

58− }

59}

42}

tests/mocks/Unity/Application/ApplicationTestInterface.cpp−51

@@ -81,54 +81,3 @@ void ApplicationTestInterface::removeSession(quint32 sessionId)

81 Session* session = m_childSessions.take(sessionId);

82 Q_EMIT session->removed();

83}

84−

85−quint32 ApplicationTestInterface::addChildSurface(const QString& appId, quint32 existingSessionId, quint32 existingSurfaceId, const QString& surfaceImage)

86−{

87− qDebug() << "ApplicationTestInterface::addChildSurface to " << appId;

88−

89− ApplicationInfo* application = ApplicationManager::singleton()->findApplication(appId);

90− if (!application) {

91− qDebug() << "ApplicationTestInterface::addChildSurface - No application found for " << appId;

92− return 0;

93− }

94−

95− MirSurfaceItem* parentSurface = nullptr;

96− if (m_childSessions.contains(existingSessionId) && m_childSessions[existingSessionId]->surface()) {

97− parentSurface = m_childSessions[existingSessionId]->surface();

98− } else if (m_childSurfaces.contains(existingSurfaceId)) {

99− parentSurface = m_childSurfaces[existingSurfaceId];

100− } else if (application->session() && application->session()->surface()) {

101− parentSurface = application->session()->surface();

102− } else {

103− qDebug() << "ApplicationTestInterface::addChildSurface - No surface for " << appId << ":" << existingSurfaceId;

104− return 0;

105− }

106−

107− QUrl screenshotUrl = QString("file://%1/Dash/graphics/phone/screenshots/%2@12.png")

108− .arg(qmlDirectory())

109− .arg(surfaceImage);

110−

111− quint32 surfaceId = ++nextId;

112− MirSurfaceItem* surface = SurfaceManager::singleton()->createSurface(

113− QString("%1-Child%2").arg(parentSurface->name())

114− .arg(surfaceId),

115− MirSurfaceItem::Normal,

116− MirSurfaceItem::Maximized,

117− screenshotUrl);

118− parentSurface->addChildSurface(surface);

119− m_childSurfaces[surfaceId] = surface;

120−

121− return surfaceId;

122−}

123−

124−void ApplicationTestInterface::removeSurface(quint32 surfaceId)

125−{

126− qDebug() << "ApplicationTestInterface::removeSurface - " << surfaceId;

127−

128− if (!m_childSurfaces.contains(surfaceId)) {

129− qDebug() << "ApplicationTestInterface::removeSurface - No added surface for " << surfaceId;

130− return;

131− }

132− MirSurfaceItem* surface = m_childSurfaces.take(surfaceId);

133− Q_EMIT surface->removed();

134−}

tests/mocks/Unity/Application/ApplicationTestInterface.h−3

@@ -32,13 +32,10 @@ public:

32

33public Q_SLOTS:

34 Q_INVOKABLE quint32 addChildSession(const QString& appId, quint32 existingSessionId, const QString& surfaceImage);

35− Q_INVOKABLE quint32 addChildSurface(const QString& appId, quint32 existingSessionId, quint32 existingSurfaceId, const QString& surfaceImage);

36 Q_INVOKABLE void removeSession(quint32 sessionId);

35 Q_INVOKABLE void removeSession(quint32 sessionId);

37− Q_INVOKABLE void removeSurface(quint32 surfaceId);

38

36

39private:

37private:

40 QHash<quint32, Session*> m_childSessions;

38 QHash<quint32, Session*> m_childSessions;

41− QHash<quint32, MirSurfaceItem*> m_childSurfaces;

42};

39};

43

40

44#endif // APPLICATIONTESTINTERFACE_H

41#endif // APPLICATIONTESTINTERFACE_H

tests/mocks/Unity/Application/MirSurfaceItem.cpp−50

@@ -38,8 +38,6 @@ MirSurfaceItem::MirSurfaceItem(const QString& name,

38 , m_name(name)

39 , m_type(type)

40 , m_state(state)

41− , m_parentSurface(nullptr)

42− , m_children(new MirSurfaceItemModel(this))

43 , m_qmlItem(nullptr)

41 , m_qmlItem(nullptr)

44 , m_screenshotUrl(screenshot)

42 , m_screenshotUrl(screenshot)

45{

43{

@@ -86,17 +84,9 @@ MirSurfaceItem::~MirSurfaceItem()

86 qDebug() << "MirSurfaceItem::~MirSurfaceItem() " << name();

84 qDebug() << "MirSurfaceItem::~MirSurfaceItem() " << name();

87 Q_EMIT aboutToBeDestroyed();

85 Q_EMIT aboutToBeDestroyed();

88

86

89− QList<MirSurfaceItem*> children(m_children->list());

90− for (MirSurfaceItem* child : children) {

91− delete child;

92− }

93− if (m_parentSurface) {

94− m_parentSurface->removeChildSurface(this);

95− }

96 if (m_session) {

87 if (m_session) {

97 m_session->setSurface(nullptr);

88 m_session->setSurface(nullptr);

98 }

89 }

99− delete m_children;

100}

90}

101

91

102void MirSurfaceItem::printComponentErrors()

92void MirSurfaceItem::printComponentErrors()

@@ -111,9 +101,6 @@ void MirSurfaceItem::release()

111{

101{

112 qDebug() << "MirSurfaceItem::release " << name();

102 qDebug() << "MirSurfaceItem::release " << name();

113

103

114− if (m_parentSurface) {

115− m_parentSurface->removeChildSurface(this);

116− }

117 if (m_session) {

104 if (m_session) {

118 m_session->setSurface(nullptr);

105 m_session->setSurface(nullptr);

119 }

106 }

@@ -136,43 +123,6 @@ void MirSurfaceItem::setScreenshot(const QUrl& screenshot)

136 }

123 }

137}

124}

138

125

139−void MirSurfaceItem::setParentSurface(MirSurfaceItem* surface)

140−{

141− if (m_parentSurface == surface || surface == this)

142− return;

143−

144− m_parentSurface = surface;

145− Q_EMIT parentSurfaceChanged(surface);

146−}

147−

148−void MirSurfaceItem::addChildSurface(MirSurfaceItem* surface)

149−{

150− insertChildSurface(m_children->rowCount(), surface);

151−}

152−

153−void MirSurfaceItem::insertChildSurface(uint index, MirSurfaceItem* surface)

154−{

155− qDebug() << "MirSurfaceItem::insertChildSurface - " << surface->name() << " to " << name() << " @ " << index;

156−

157− surface->setParentSurface(this);

158− m_children->insert(index, surface);

159−}

160−

161−void MirSurfaceItem::removeChildSurface(MirSurfaceItem* surface)

162−{

163− qDebug() << "MirSurfaceItem::removeChildSurface - " << surface->name() << " from " << name();

164−

165− if (m_children->contains(surface)) {

166− m_children->remove(surface);

167− surface->setParentSurface(nullptr);

168− }

169−}

170−

171−MirSurfaceItemModel* MirSurfaceItem::childSurfaces() const

172−{

173− return m_children;

174−}

175−

176void MirSurfaceItem::onQmlWantInputMethodChanged()

126void MirSurfaceItem::onQmlWantInputMethodChanged()

177{

127{

178 QQmlProperty prop(m_qmlItem, "wantInputMethod");

128 QQmlProperty prop(m_qmlItem, "wantInputMethod");

tests/mocks/Unity/Application/MirSurfaceItem.h−13

@@ -33,8 +33,6 @@ class MirSurfaceItem : public QQuickItem

33 Q_PROPERTY(Type type READ type NOTIFY typeChanged)

34 Q_PROPERTY(State state READ state NOTIFY stateChanged)

35 Q_PROPERTY(QString name READ name CONSTANT)

36− Q_PROPERTY(MirSurfaceItem* parentSurface READ parentSurface NOTIFY parentSurfaceChanged DESIGNABLE false)

37− Q_PROPERTY(MirSurfaceItemModel* childSurfaces READ childSurfaces DESIGNABLE false CONSTANT)

38

36

39public:

37public:

40 enum Type {

38 enum Type {

@@ -64,7 +62,6 @@ public:

64 Type type() const { return m_type; }

62 Type type() const { return m_type; }

65 State state() const { return m_state; }

63 State state() const { return m_state; }

66 QString name() const { return m_name; }

64 QString name() const { return m_name; }

67− MirSurfaceItem* parentSurface() const { return m_parentSurface; }

68

65

69 void setSession(Session* item);

66 void setSession(Session* item);

70 void setScreenshot(const QUrl& screenshot);

67 void setScreenshot(const QUrl& screenshot);

@@ -72,10 +69,6 @@ public:

72 Q_INVOKABLE void setState(State newState);

69 Q_INVOKABLE void setState(State newState);

73 Q_INVOKABLE void release();

70 Q_INVOKABLE void release();

74

71

75− Q_INVOKABLE void addChildSurface(MirSurfaceItem* surface);

76− void insertChildSurface(uint index, MirSurfaceItem* surface);

77− void removeChildSurface(MirSurfaceItem* surface);

78−

79Q_SIGNALS:

72Q_SIGNALS:

80 void typeChanged(Type);

73 void typeChanged(Type);

81 void stateChanged(State);

74 void stateChanged(State);

@@ -101,9 +94,6 @@ private:

101 const QString &qmlFilePath = QString(),

94 const QString &qmlFilePath = QString(),

102 QQuickItem *parent = 0);

95 QQuickItem *parent = 0);

103

96

104− MirSurfaceItemModel* childSurfaces() const;

105− void setParentSurface(MirSurfaceItem* surface);

106−

107 void createQmlContentItem();

97 void createQmlContentItem();

108 void printComponentErrors();

98 void printComponentErrors();

109

99

@@ -112,9 +102,6 @@ private:

112 const Type m_type;

102 const Type m_type;

113 State m_state;

103 State m_state;

114

104

115− MirSurfaceItem* m_parentSurface;

116− MirSurfaceItemModel* m_children;

117−

118 QQmlComponent *m_qmlContentComponent;

105 QQmlComponent *m_qmlContentComponent;

119 QQuickItem *m_qmlItem;

106 QQuickItem *m_qmlItem;

120 QUrl m_screenshotUrl;

107 QUrl m_screenshotUrl;

tests/qmltests/Stages/tst_SurfaceContainer.qml−68

@@ -123,73 +123,5 @@ Rectangle {

123 compare(fakeSurface.width, surfaceContainerLoader.item.width);

124 compare(fakeSurface.height, surfaceContainerLoader.item.height);

125 }

126−

127− function test_childSurfaces_data() {

128− return [ { tag: "1", count: 1 },

129− { tag: "4", count: 4 } ];

130− }

131−

132− function test_childSurfaces(data) {

133− var surfaceContainer = surfaceContainerLoader.item;

134− surfaceCheckbox.checked = true;

135−

136− var i;

137− var surfaces = [];

138− for (i = 0; i < data.count; i++) {

139− var surface = SurfaceManager.createSurface(surfaceContainer.surface.name + "-Child" + i,

140− MirSurfaceItem.Normal,

141− MirSurfaceItem.Restored,

142− Qt.resolvedUrl("../Dash/artwork/music-player-design.png"));

143− surfaceContainer.surface.addChildSurface(surface);

144− compare(surfaceContainer.childSurfaces.count(), i+1);

145−

146− surfaces.push(surface);

147− }

148−

149− for (i = data.count-1; i >= 0; i--) {

150− surfaces[i].release();

151− tryCompareFunction(function() { return surfaceContainer.childSurfaces.count(); }, i);

152− }

153− tryCompare(surfaceSpy, "count", data.count);

154− }

155−

156− function test_nestedChildSurfaces_data() {

157− return [

158− { tag: "2", count: 2 },

159− { tag: "10", count: 10 }

160− ];

161− }

162−

163− function test_nestedChildSurfaces(data) {

164− var surfaceContainer = surfaceContainerLoader.item;

165− surfaceCheckbox.checked = true;

166−

167− var i;

168− var surfaces = [];

169− var lastSurface = surfaceContainer.surface;

170− var delegate;

171− var container = surfaceContainer;

172− for (i = 0; i < data.count; i++) {

173− var surface = SurfaceManager.createSurface(surfaceContainer.surface.name + "-Child" + i,

174− MirSurfaceItem.Normal,

175− MirSurfaceItem.Restored,

176− Qt.resolvedUrl("../Dash/artwork/music-player-design.png"));

177− lastSurface.addChildSurface(surface);

178− compare(container.childSurfaces.count(), 1);

179− surfaces.push(surface);

180−

181− delegate = findChild(container, "childDelegate0");

182− container = findChild(delegate, "surfaceContainer");

183− lastSurface = surface;

184− }

185−

186− surfaceSpy.clear();

187− for (i = data.count-1; i >= 0; i--) {

188− surfaces[i].release();

189− }

190−

191− compare(surfaceContainer.childSurfaces.count(), 0);

192− tryCompare(surfaceSpy, "count", data.count)

193− }

194 }

126 }

195}

127}