git.iko.soy/unity8
on fdb4474 help sign in
unity8/Shell.qml
552 lines 20 kB history raw
1/*
2 * Copyright (C) 2013 Canonical, Ltd.
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 */
17import QtQuick 2.0
18import Ubuntu.Application 0.1
19import Ubuntu.Components 0.1
20import Ubuntu.Gestures 0.1
21import Powerd 0.1
22import SessionManager 0.1
23import "Dash"
24import "Launcher"
25import "Panel"
26import "Hud"
27import "Components"
28import "Components/Math.js" as MathLocal
29import "Bottombar"
30import "SideStage"
31import "Notifications"
32import Unity.Notifications 1.0 as NotificationBackend
34BasicShell {
35 id: shell
37 readonly property real panelHeight: panel.panelHeight
39 property bool dashShown: dash.shown
40 property bool stageScreenshotsReady: {
41 if (sideStage.shown) {
42 if (mainStage.applications.count > 0) {
43 return mainStage.usingScreenshots && sideStage.usingScreenshots;
44 } else {
45 return sideStage.usingScreenshots;
46 }
47 } else {
48 return mainStage.usingScreenshots;
49 }
50 }
52 property ListModel searchHistory: SearchHistoryModel {}
54 property var applicationManager: ApplicationManagerWrapper {}
56 Component.onCompleted: {
57 Theme.name = "Ubuntu.Components.Themes.SuruGradient"
59 applicationManager.sideStageEnabled = Qt.binding(function() { return sideStage.enabled })
61 // FIXME: if application focused before shell starts, shell draws on top of it only.
62 // We should detect already running applications on shell start and bring them to the front.
63 applicationManager.unfocusCurrentApplication();
64 }
66 readonly property bool fullscreenMode: {
67 if (mainStage.usingScreenshots) { // Window Manager animating so want to re-evaluate fullscreen mode
68 return mainStage.switchingFromFullscreenToFullscreen;
69 } else if (applicationManager.mainStageFocusedApplication) {
70 return applicationManager.mainStageFocusedApplication.fullscreen;
71 } else {
72 return false;
73 }
74 }
76 Connections {
77 target: applicationManager
78 ignoreUnknownSignals: true
79 onFocusRequested: {
80 shell.activateApplication(desktopFile);
81 }
82 }
84 function activateApplication(desktopFile, argument) {
85 if (applicationManager) {
86 // For newly started applications, as it takes them time to draw their first frame
87 // we add a delay before we hide the animation screenshots to compensate.
88 var addDelay = !applicationManager.getApplicationFromDesktopFile(desktopFile);
90 var application;
91 application = applicationManager.activateApplication(desktopFile, argument);
92 if (application == null) {
93 return;
94 }
95 if (application.stage == ApplicationInfo.MainStage || !sideStage.enabled) {
96 mainStage.activateApplication(desktopFile, addDelay);
97 } else {
98 sideStage.activateApplication(desktopFile, addDelay);
99 }
100 stages.show();
101 }
102 }
104 Item {
105 id: underlay
106 objectName: "underlay"
107 anchors.fill: parent
109 // Whether the underlay is fully covered by opaque UI elements.
110 property bool fullyCovered: panel.indicators.fullyOpened && shell.width <= panel.indicatorsMenuWidth
112 // Whether the user should see the topmost application surface (if there's one at all).
113 property bool applicationSurfaceShouldBeSeen:
114 (mainStage.applications && mainStage.applications.count > 0)
115 && (!stages.fullyHidden && !mainStage.usingScreenshots)
117 // NB! Application surfaces are stacked behing the shell one. So they can only be seen by the user
118 // through the translucent parts of the shell surface.
119 visible: !fullyCovered && !applicationSurfaceShouldBeSeen
121 Image {
122 id: backgroundImage
123 source: shell.background
124 sourceSize.width: parent.width
125 sourceSize.height: parent.height
126 anchors.fill: parent
127 }
129 Rectangle {
130 anchors.fill: parent
131 color: "black"
132 opacity: dash.disappearingAnimationProgress
133 }
135 Dash {
136 id: dash
137 objectName: "dash"
139 hides: [stages, launcher, panel.indicators]
140 shown: disappearingAnimationProgress !== 1.0
141 enabled: disappearingAnimationProgress === 0.0
142 // FIXME: unfocus all applications when going back to the dash
143 onEnabledChanged: {
144 if (enabled) {
145 shell.applicationManager.unfocusCurrentApplication()
146 }
147 }
149 anchors {
150 fill: parent
151 topMargin: panel.panelHeight
152 }
154 contentScale: 1.0 - 0.2 * disappearingAnimationProgress
155 opacity: 1.0 - disappearingAnimationProgress
156 property real disappearingAnimationProgress: stagesOuterContainer.showProgress
158 // FIXME: only necessary because stagesOuterContainer.showProgress
159 // is not animated
160 Behavior on disappearingAnimationProgress { SmoothedAnimation { velocity: 5 }}
161 }
162 }
165 Item {
166 id: stagesOuterContainer
168 width: parent.width
169 height: parent.height
170 x: launcher.progress
171 Behavior on x {SmoothedAnimation{velocity: 600}}
173 property real showProgress:
174 MathLocal.clamp(1 - (x + stages.x) / shell.width, 0, 1)
176 Showable {
177 id: stages
178 objectName: "stages"
180 x: width
182 property bool fullyShown: shown && x == 0 && parent.x == 0
183 property bool fullyHidden: !shown && x == width
184 hides: [launcher, panel.indicators]
185 shown: false
186 opacity: 1.0
187 showAnimation: StandardAnimation { property: "x"; duration: 350; to: 0; easing.type: Easing.OutCubic }
188 hideAnimation: StandardAnimation { property: "x"; duration: 350; to: width; easing.type: Easing.OutCubic }
190 width: parent.width
191 height: parent.height
193 // close the stages when no focused application remains
194 Connections {
195 target: shell.applicationManager
196 onMainStageFocusedApplicationChanged: stages.closeIfNoApplications()
197 onSideStageFocusedApplicationChanged: stages.closeIfNoApplications()
198 ignoreUnknownSignals: true
199 }
201 function closeIfNoApplications() {
202 if (!shell.applicationManager.mainStageFocusedApplication
203 && !shell.applicationManager.sideStageFocusedApplication
204 && shell.applicationManager.mainStageApplications.count == 0
205 && shell.applicationManager.sideStageApplications.count == 0) {
206 stages.hide();
207 }
208 }
210 // show the stages when an application gets the focus
211 Connections {
212 target: shell.applicationManager
213 onMainStageFocusedApplicationChanged: {
214 if (shell.applicationManager.mainStageFocusedApplication) {
215 mainStage.show();
216 stages.show();
217 }
218 }
219 onSideStageFocusedApplicationChanged: {
220 if (shell.applicationManager.sideStageFocusedApplication) {
221 sideStage.show();
222 stages.show();
223 }
224 }
225 ignoreUnknownSignals: true
226 }
229 Stage {
230 id: mainStage
232 anchors.fill: parent
233 fullyShown: stages.fullyShown
234 fullyHidden: stages.fullyHidden
235 shouldUseScreenshots: !fullyShown
236 rightEdgeEnabled: !sideStage.enabled
238 applicationManager: shell.applicationManager
239 rightEdgeDraggingAreaWidth: shell.edgeSize
240 normalApplicationY: shell.panelHeight
242 shown: true
243 function show() {
244 stages.show();
245 }
246 function hide() {
247 }
249 // FIXME: workaround the fact that focusing a main stage application
250 // raises its surface on top of all other surfaces including the ones
251 // that belong to side stage applications.
252 onFocusedApplicationChanged: {
253 if (focusedApplication && sideStage.focusedApplication && sideStage.fullyShown) {
254 shell.applicationManager.focusApplication(sideStage.focusedApplication);
255 }
256 }
257 }
259 SideStage {
260 id: sideStage
262 applicationManager: shell.applicationManager
263 rightEdgeDraggingAreaWidth: shell.edgeSize
264 normalApplicationY: shell.panelHeight
266 onShownChanged: {
267 if (!shown && mainStage.applications.count == 0) {
268 stages.hide();
269 }
270 }
271 // FIXME: when hiding the side stage, refocus the main stage
272 // application so that it goes in front of the side stage
273 // application and hides it
274 onFullyShownChanged: {
275 if (!fullyShown && stages.fullyShown && sideStage.focusedApplication != null) {
276 shell.applicationManager.focusApplication(mainStage.focusedApplication);
277 }
278 }
280 enabled: shell.width >= units.gu(60)
281 visible: enabled
282 fullyShown: stages.fullyShown && shown
283 && sideStage[sideStageRevealer.boundProperty] == sideStageRevealer.openedValue
284 shouldUseScreenshots: !fullyShown || mainStage.usingScreenshots || sideStageRevealer.pressed
286 available: enabled
287 hides: [launcher, panel.indicators]
288 shown: false
289 showAnimation: StandardAnimation { property: "x"; duration: 350; to: sideStageRevealer.openedValue; easing.type: Easing.OutQuint }
290 hideAnimation: StandardAnimation { property: "x"; duration: 350; to: sideStageRevealer.closedValue; easing.type: Easing.OutQuint }
292 width: units.gu(40)
293 height: stages.height
294 handleExpanded: sideStageRevealer.pressed
295 }
297 Revealer {
298 id: sideStageRevealer
300 enabled: mainStage.applications.count > 0 && sideStage.applications.count > 0
301 && sideStage.available
302 direction: Qt.RightToLeft
303 openedValue: parent.width - sideStage.width
304 hintDisplacement: units.gu(3)
305 /* The size of the sidestage handle needs to be bigger than the
306 typical size used for edge detection otherwise it is really
307 hard to grab.
308 */
309 handleSize: sideStage.shown ? units.gu(4) : shell.edgeSize
310 closedValue: parent.width + sideStage.handleSizeCollapsed
311 target: sideStage
312 x: parent.width - width
313 width: sideStage.width + handleSize * 0.7
314 height: sideStage.height
315 orientation: Qt.Horizontal
316 }
318 DragHandle {
319 id: stagesDragHandle
321 anchors.top: parent.top
322 anchors.bottom: parent.bottom
323 anchors.right: parent.left
325 width: shell.edgeSize
326 direction: Direction.Leftwards
327 property bool haveApps: mainStage.applications.count > 0 || sideStage.applications.count > 0
329 maxTotalDragDistance: haveApps ? parent.width : parent.width * 0.7
330 // Make autocompletion impossible when !haveApps
331 edgeDragEvaluator.minDragDistance: haveApps ? maxTotalDragDistance * 0.1 : Number.MAX_VALUE
332 }
333 }
334 }
336 Connections {
337 id: powerConnection
338 target: Powerd
340 property var previousMainApp: null
341 property var previousSideApp: null
343 function setFocused(focused) {
344 if (!focused) {
345 // FIXME: *FocusedApplication are not updated when unfocused, hence the need to check whether
346 // the stage was actually shown
347 if (mainStage.fullyShown) powerConnection.previousMainApp = applicationManager.mainStageFocusedApplication;
348 if (sideStage.fullyShown) powerConnection.previousSideApp = applicationManager.sideStageFocusedApplication;
349 applicationManager.unfocusCurrentApplication();
350 } else {
351 if (powerConnection.previousMainApp) {
352 applicationManager.focusApplication(powerConnection.previousMainApp);
353 powerConnection.previousMainApp = null;
354 }
355 if (powerConnection.previousSideApp) {
356 applicationManager.focusApplication(powerConnection.previousSideApp);
357 powerConnection.previousSideApp = null;
358 }
359 }
360 }
362 onPowerStateChange: {
363 if (state == 0) { // suspend
364 powerConnection.setFocused(false);
365 SessionManager.lock();
366 } else if (state == 1) { // active
367 powerConnection.setFocused(true);
368 }
369 }
370 }
372 Item {
373 id: overlay
375 anchors.fill: parent
377 Panel {
378 id: panel
379 anchors.fill: parent //because this draws indicator menus
380 indicatorsMenuWidth: parent.width > units.gu(60) ? units.gu(40) : parent.width
381 indicators {
382 hides: [launcher]
383 }
384 fullscreenMode: shell.fullscreenMode
386 InputFilterArea {
387 anchors.fill: parent
388 blockInput: panel.indicators.shown
389 }
390 }
392 Hud {
393 id: hud
395 width: parent.width > units.gu(60) ? units.gu(40) : parent.width
396 height: parent.height
398 available: !panel.indicators.shown
399 shown: false
400 showAnimation: StandardAnimation { property: "y"; duration: hud.showableAnimationDuration; to: 0; easing.type: Easing.Linear }
401 hideAnimation: StandardAnimation { property: "y"; duration: hud.showableAnimationDuration; to: hudRevealer.closedValue; easing.type: Easing.Linear }
403 Connections {
404 target: shell.applicationManager
405 onMainStageFocusedApplicationChanged: hud.hide()
406 onSideStageFocusedApplicationChanged: hud.hide()
407 }
409 InputFilterArea {
410 anchors.fill: parent
411 blockInput: hud.shown
412 }
413 }
415 Revealer {
416 id: hudRevealer
418 enabled: hud.shown
419 width: hud.width
420 anchors.left: hud.left
421 height: parent.height
422 target: hud.revealerTarget
423 closedValue: height
424 openedValue: 0
425 direction: Qt.RightToLeft
426 orientation: Qt.Vertical
427 handleSize: hud.handleHeight
428 onCloseClicked: target.hide()
429 }
431 Bottombar {
432 theHud: hud
433 anchors.fill: parent
434 enabled: !panel.indicators.shown
435 applicationIsOnForeground: applicationManager.mainStageFocusedApplication
436 || applicationManager.sideStageFocusedApplication
437 }
439 InputFilterArea {
440 blockInput: launcher.shown
441 anchors {
442 top: parent.top
443 bottom: parent.bottom
444 left: parent.left
445 }
446 width: launcher.width
447 }
449 Launcher {
450 id: launcher
452 anchors.top: parent.top
453 anchors.bottom: parent.bottom
454 width: parent.width
455 dragAreaWidth: shell.edgeSize
456 onDashItemSelected: {
457 // Animate if moving between application and dash
458 if (!stages.shown) {
459 dash.setCurrentScope("home.scope", true, false)
460 } else {
461 dash.setCurrentScope("home.scope", false, false)
462 }
463 stages.hide();
464 }
465 onDash: {
466 if (stages.shown) {
467 dash.setCurrentScope("applications.scope", true, false)
468 stages.hide();
469 launcher.hide();
470 }
471 }
472 onLauncherApplicationSelected:{
473 shell.activateApplication(desktopFile)
474 }
475 onShownChanged: {
476 if (shown) {
477 panel.indicators.hide()
478 hud.hide()
479 }
480 }
481 }
483 Notifications {
484 id: notifications
486 model: NotificationBackend.Model
487 anchors {
488 top: parent.top
489 right: parent.right
490 bottom: parent.bottom
491 leftMargin: units.gu(1)
492 rightMargin: units.gu(1)
493 topMargin: panel.panelHeight + units.gu(1)
494 }
495 states: [
496 State {
497 name: "narrow"
498 when: overlay.width <= units.gu(60)
499 AnchorChanges { target: notifications; anchors.left: parent.left }
500 },
501 State {
502 name: "wide"
503 when: overlay.width > units.gu(60)
504 AnchorChanges { target: notifications; anchors.left: undefined }
505 PropertyChanges { target: notifications; width: units.gu(38) }
506 }
507 ]
508 }
509 }
511 focus: true
513 InputFilterArea {
514 anchors {
515 top: parent.top
516 bottom: parent.bottom
517 left: parent.left
518 }
519 width: shell.edgeSize
520 blockInput: true
521 }
523 Binding {
524 target: i18n
525 property: "domain"
526 value: "unity8"
527 }
529 //FIXME: This should be handled in the input stack, keyboard shouldnt propagate
530 MouseArea {
531 anchors.bottom: parent.bottom
532 anchors.left: parent.left
533 anchors.right: parent.right
534 height: shell.applicationManager ? shell.applicationManager.keyboardHeight : 0
536 enabled: shell.applicationManager && shell.applicationManager.keyboardVisible
537 }
539 Label {
540 anchors.fill: parent
541 visible: applicationManager.fake
542 text: "EARLY ALPHA\nNOT READY FOR USE"
543 color: "lightgrey"
544 opacity: 0.2
545 font.weight: Font.Black
546 horizontalAlignment: Text.AlignHCenter
547 verticalAlignment: Text.AlignVCenter
548 fontSizeMode: Text.Fit
549 font.pixelSize: height/2
550 rotation: -45
551 }