git.iko.soy/unity8
on 40eeb37 help sign in
unity8/qml/Shell.qml
709 lines 24 kB history raw
1/*
2 * Copyright (C) 2013-2016 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.4
18import QtQuick.Window 2.2
19import AccountsService 0.1
20import Unity.Application 0.1
21import Ubuntu.Components 1.3
22import Ubuntu.Components.Popups 1.3
23import Ubuntu.Gestures 0.1
24import Ubuntu.Telephony 0.1 as Telephony
25import Unity.Connectivity 0.1
26import Unity.Launcher 0.1
27import GlobalShortcut 1.0 // has to be before Utils, because of WindowKeysFilter
28import Utils 0.1
29import Powerd 0.1
30import SessionBroadcast 0.1
31import "Greeter"
32import "Launcher"
33import "Panel"
34import "Components"
35import "Notifications"
36import "Stages"
37import "Tutorial"
38import "Wizard"
39import Unity.Notifications 1.0 as NotificationBackend
40import Unity.Session 0.1
41import Unity.DashCommunicator 0.1
42import Unity.Indicators 0.1 as Indicators
43import Cursor 1.0
46Item {
47 id: shell
49 // to be set from outside
50 property int orientationAngle: 0
51 property int orientation
52 property Orientations orientations
53 property real nativeWidth
54 property real nativeHeight
55 property alias indicatorAreaShowProgress: panel.indicatorAreaShowProgress
56 property bool beingResized
57 property string usageScenario: "phone" // supported values: "phone", "tablet" or "desktop"
58 property string mode: "full-greeter"
59 property alias oskEnabled: inputMethod.enabled
60 function updateFocusedAppOrientation() {
61 applicationsDisplayLoader.item.updateFocusedAppOrientation();
62 }
63 function updateFocusedAppOrientationAnimated() {
64 applicationsDisplayLoader.item.updateFocusedAppOrientationAnimated();
65 }
66 property bool hasMouse: false
68 // to be read from outside
69 readonly property int mainAppWindowOrientationAngle:
70 applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainAppWindowOrientationAngle : 0
72 readonly property bool orientationChangesEnabled: panel.indicators.fullyClosed
73 && (applicationsDisplayLoader.item && applicationsDisplayLoader.item.orientationChangesEnabled)
74 && (!greeter || !greeter.animating)
76 readonly property bool showingGreeter: greeter && greeter.shown
78 property bool startingUp: true
79 Timer { id: finishStartUpTimer; interval: 500; onTriggered: startingUp = false }
81 property int supportedOrientations: {
82 if (startingUp) {
83 // Ensure we don't rotate during start up
84 return Qt.PrimaryOrientation;
85 } else if (greeter && greeter.shown) {
86 return Qt.PrimaryOrientation;
87 } else if (applicationsDisplayLoader.item) {
88 return shell.orientations.map(applicationsDisplayLoader.item.supportedOrientations);
89 } else {
90 // we just don't care
91 return Qt.PortraitOrientation
92 | Qt.LandscapeOrientation
93 | Qt.InvertedPortraitOrientation
94 | Qt.InvertedLandscapeOrientation;
95 }
96 }
98 // For autopilot consumption
99 readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
101 // internal props from here onwards
102 readonly property var mainApp:
103 applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainApp : null
105 // Disable everything while greeter is waiting, so that the user can't swipe
106 // the greeter or launcher until we know whether the session is locked.
107 enabled: greeter && !greeter.waiting
109 property real edgeSize: units.gu(2)
111 WallpaperResolver {
112 id: wallpaperResolver
113 width: shell.width
114 }
116 readonly property alias greeter: greeterLoader.item
118 function activateApplication(appId) {
119 if (ApplicationManager.findApplication(appId)) {
120 ApplicationManager.requestFocusApplication(appId);
121 } else {
122 var execFlags = shell.usageScenario === "phone" ? ApplicationManager.ForceMainStage
123 : ApplicationManager.NoFlag;
124 ApplicationManager.startApplication(appId, execFlags);
125 }
126 }
128 function startLockedApp(app) {
129 if (greeter.locked) {
130 greeter.lockedApp = app;
131 }
132 shell.activateApplication(app);
133 }
135 Binding {
136 target: LauncherModel
137 property: "applicationManager"
138 value: ApplicationManager
139 }
141 Component.onCompleted: {
142 theme.name = "Ubuntu.Components.Themes.SuruGradient"
143 if (ApplicationManager.count > 0) {
144 ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
145 }
146 finishStartUpTimer.start();
147 }
149 LightDM{id: lightDM} // Provide backend access
150 VolumeControl {
151 id: volumeControl
152 indicators: panel.indicators
153 }
155 DashCommunicator {
156 id: dash
157 objectName: "dashCommunicator"
158 }
160 PhysicalKeysMapper {
161 id: physicalKeysMapper
162 objectName: "physicalKeysMapper"
164 onPowerKeyLongPressed: dialogs.showPowerDialog();
165 onVolumeDownTriggered: volumeControl.volumeDown();
166 onVolumeUpTriggered: volumeControl.volumeUp();
167 onScreenshotTriggered: screenGrabber.capture();
168 }
170 GlobalShortcut {
171 // dummy shortcut to force creation of GlobalShortcutRegistry before WindowKeyFilter
172 }
174 WindowKeysFilter {
175 Keys.onPressed: physicalKeysMapper.onKeyPressed(event, currentEventTimestamp);
176 Keys.onReleased: physicalKeysMapper.onKeyReleased(event, currentEventTimestamp);
177 }
179 WindowInputMonitor {
180 onHomeKeyActivated: { launcher.fadeOut(); shell.showHome(); }
181 onTouchBegun: { cursor.opacity = 0; }
182 onTouchEnded: {
183 // move the (hidden) cursor to the last known touch position
184 var mappedCoords = mapFromItem(null, pos.x, pos.y);
185 cursor.x = mappedCoords.x;
186 cursor.y = mappedCoords.y;
187 }
188 }
190 Item {
191 id: stages
192 objectName: "stages"
193 width: parent.width
194 height: parent.height
196 Connections {
197 target: ApplicationManager
199 // This signal is also fired when we try to focus the current app
200 // again. We rely on this!
201 onFocusedApplicationIdChanged: {
202 var appId = ApplicationManager.focusedApplicationId;
204 if (tutorial.running && appId != "" && appId != "unity8-dash") {
205 // If this happens on first boot, we may be in edge
206 // tutorial or wizard while receiving a call. But a call
207 // is more important than wizard so just bail out of those.
208 tutorial.finish();
209 wizard.hide();
210 }
212 if (appId === "dialer-app" && callManager.hasCalls && greeter.locked) {
213 // If we are in the middle of a call, make dialer lockedApp and show it.
214 // This can happen if user backs out of dialer back to greeter, then
215 // launches dialer again.
216 greeter.lockedApp = appId;
217 }
218 greeter.notifyAppFocused(appId);
220 panel.indicators.hide();
221 }
223 onApplicationAdded: {
224 launcher.hide();
225 }
226 }
228 Loader {
229 id: applicationsDisplayLoader
230 objectName: "applicationsDisplayLoader"
231 anchors.fill: parent
233 // When we have a locked app, we only want to show that one app.
234 // FIXME: do this in a less traumatic way. We currently only allow
235 // locked apps in phone mode (see FIXME in Lockscreen component in
236 // this same file). When that changes, we need to do something
237 // nicer here. But this code is currently just to prevent a
238 // theoretical attack where user enters lockedApp mode, then makes
239 // the screen larger (maybe connects to monitor) and tries to enter
240 // tablet mode.
242 property string usageScenario: shell.usageScenario === "phone" || greeter.hasLockedApp
243 ? "phone"
244 : shell.usageScenario
245 source: {
246 if(shell.mode === "greeter") {
247 return "Stages/ShimStage.qml"
248 } else if (applicationsDisplayLoader.usageScenario === "phone") {
249 return "Stages/PhoneStage.qml";
250 } else if (applicationsDisplayLoader.usageScenario === "tablet") {
251 return "Stages/TabletStage.qml";
252 } else {
253 return "Stages/DesktopStage.qml";
254 }
255 }
257 property bool interactive: tutorial.spreadEnabled
258 && (!greeter || !greeter.shown)
259 && panel.indicators.fullyClosed
260 && launcher.progress == 0
261 && !notifications.useModal
263 onInteractiveChanged: { if (interactive) { focus = true; } }
265 Binding {
266 target: applicationsDisplayLoader.item
267 property: "objectName"
268 value: "stage"
269 }
270 Binding {
271 target: applicationsDisplayLoader.item
272 property: "dragAreaWidth"
273 value: shell.edgeSize
274 }
275 Binding {
276 target: applicationsDisplayLoader.item
277 property: "maximizedAppTopMargin"
278 // Not just using panel.panelHeight as that changes depending on the focused app.
279 value: panel.indicators.minimizedPanelHeight
280 }
281 Binding {
282 target: applicationsDisplayLoader.item
283 property: "interactive"
284 value: applicationsDisplayLoader.interactive
285 }
286 Binding {
287 target: applicationsDisplayLoader.item
288 property: "spreadEnabled"
289 value: tutorial.spreadEnabled && (!greeter || (!greeter.hasLockedApp && !greeter.shown))
290 }
291 Binding {
292 target: applicationsDisplayLoader.item
293 property: "inverseProgress"
294 value: greeter && greeter.locked ? 0 : launcher.progress
295 }
296 Binding {
297 target: applicationsDisplayLoader.item
298 property: "shellOrientationAngle"
299 value: shell.orientationAngle
300 }
301 Binding {
302 target: applicationsDisplayLoader.item
303 property: "shellOrientation"
304 value: shell.orientation
305 }
306 Binding {
307 target: applicationsDisplayLoader.item
308 property: "orientations"
309 value: shell.orientations
310 }
311 Binding {
312 target: applicationsDisplayLoader.item
313 property: "background"
314 value: wallpaperResolver.background
315 }
316 Binding {
317 target: applicationsDisplayLoader.item
318 property: "nativeWidth"
319 value: shell.nativeWidth
320 }
321 Binding {
322 target: applicationsDisplayLoader.item
323 property: "nativeHeight"
324 value: shell.nativeHeight
325 }
326 Binding {
327 target: applicationsDisplayLoader.item
328 property: "beingResized"
329 value: shell.beingResized
330 }
331 Binding {
332 target: applicationsDisplayLoader.item
333 property: "keepDashRunning"
334 value: launcher.shown || launcher.dashSwipe
335 }
336 Binding {
337 target: applicationsDisplayLoader.item
338 property: "suspended"
339 value: greeter.shown
340 }
341 Binding {
342 target: applicationsDisplayLoader.item
343 property: "altTabPressed"
344 value: physicalKeysMapper.altTabPressed
345 }
346 }
348 Tutorial {
349 id: tutorial
350 objectName: "tutorial"
351 anchors.fill: parent
353 // EdgeDragAreas don't work with mice. So to avoid trapping the user,
354 // we skip the tutorial on the Desktop to avoid using them. The
355 // Desktop doesn't use the same spread design anyway. The tutorial is
356 // all a bit of a placeholder on non-phone form factors right now.
357 // When the design team gives us more guidance, we can do something
358 // more clever here.
359 active: usageScenario != "desktop" && AccountsService.demoEdges
361 paused: lightDM.greeter.active
362 launcher: launcher
363 panel: panel
364 edgeSize: shell.edgeSize
366 onFinished: {
367 AccountsService.demoEdges = false;
368 active = false; // for immediate response / if AS is having problems
369 }
370 }
371 }
373 InputMethod {
374 id: inputMethod
375 objectName: "inputMethod"
376 anchors { fill: parent; topMargin: panel.panelHeight }
377 z: notifications.useModal || panel.indicators.shown || wizard.active ? overlay.z + 1 : overlay.z - 1
378 }
380 Connections {
381 target: SessionManager
382 onSessionStopping: {
383 if (!session.parentSession && !session.application) {
384 // nothing is using it. delete it right away
385 session.release();
386 }
387 }
388 }
390 Loader {
391 id: greeterLoader
392 anchors.fill: parent
393 anchors.topMargin: panel.panelHeight
394 sourceComponent: shell.mode != "shell" ? integratedGreeter :
395 Qt.createComponent(Qt.resolvedUrl("Greeter/ShimGreeter.qml"));
396 onLoaded: {
397 item.objectName = "greeter"
398 }
399 }
401 Component {
402 id: integratedGreeter
403 Greeter {
405 hides: [launcher, panel.indicators]
406 tabletMode: shell.usageScenario != "phone"
407 launcherOffset: launcher.progress
408 forcedUnlock: tutorial.running
409 background: wallpaperResolver.background
411 // avoid overlapping with Launcher's edge drag area
412 // FIXME: Fix TouchRegistry & friends and remove this workaround
413 // Issue involves launcher's DDA getting disabled on a long
414 // left-edge drag
415 dragHandleLeftMargin: launcher.available ? launcher.dragAreaWidth + 1 : 0
417 onSessionStarted: {
418 launcher.hide();
419 }
421 onTease: {
422 if (!tutorial.running) {
423 launcher.tease();
424 }
425 }
427 onEmergencyCall: startLockedApp("dialer-app")
428 }
429 }
431 Timer {
432 // See powerConnection for why this is useful
433 id: showGreeterDelayed
434 interval: 1
435 onTriggered: {
436 greeter.forceShow();
437 }
438 }
440 Connections {
441 id: callConnection
442 target: callManager
444 onHasCallsChanged: {
445 if (greeter.locked && callManager.hasCalls && greeter.lockedApp !== "dialer-app") {
446 // We just received an incoming call while locked. The
447 // indicator will have already launched dialer-app for us, but
448 // there is a race between "hasCalls" changing and the dialer
449 // starting up. So in case we lose that race, we'll start/
450 // focus the dialer ourselves here too. Even if the indicator
451 // didn't launch the dialer for some reason (or maybe a call
452 // started via some other means), if an active call is
453 // happening, we want to be in the dialer.
454 startLockedApp("dialer-app")
455 }
456 }
457 }
459 Connections {
460 id: powerConnection
461 target: Powerd
463 onStatusChanged: {
464 if (Powerd.status === Powerd.Off && reason !== Powerd.Proximity &&
465 !callManager.hasCalls && !tutorial.running) {
466 // We don't want to simply call greeter.showNow() here, because
467 // that will take too long. Qt will delay button event
468 // handling until the greeter is done loading and may think the
469 // user held down the power button the whole time, leading to a
470 // power dialog being shown. Instead, delay showing the
471 // greeter until we've finished handling the event. We could
472 // make the greeter load asynchronously instead, but that
473 // introduces a whole host of timing issues, especially with
474 // its animations. So this is simpler.
475 showGreeterDelayed.start();
476 }
477 }
478 }
480 function showHome() {
481 if (tutorial.running) {
482 return
483 }
485 greeter.notifyAboutToFocusApp("unity8-dash");
487 var animate = !lightDM.greeter.active && !stages.shown
488 dash.setCurrentScope(0, animate, false)
489 ApplicationManager.requestFocusApplication("unity8-dash")
490 }
492 function showDash() {
493 if (greeter.notifyShowingDashFromDrag()) {
494 launcher.fadeOut();
495 }
497 if (!greeter.locked && ApplicationManager.focusedApplicationId != "unity8-dash") {
498 ApplicationManager.requestFocusApplication("unity8-dash")
499 launcher.fadeOut();
500 }
501 }
503 Item {
504 id: overlay
505 z: 10
507 anchors.fill: parent
509 Panel {
510 id: panel
511 objectName: "panel"
512 anchors.fill: parent //because this draws indicator menus
513 indicators {
514 hides: [launcher]
515 available: tutorial.panelEnabled
516 && ((!greeter || !greeter.locked) || AccountsService.enableIndicatorsWhileLocked)
517 && (!greeter || !greeter.hasLockedApp)
518 contentEnabled: tutorial.panelContentEnabled
519 width: parent.width > units.gu(60) ? units.gu(40) : parent.width
521 minimizedPanelHeight: units.gu(3)
522 expandedPanelHeight: units.gu(7)
524 indicatorsModel: Indicators.IndicatorsModel {
525 // tablet and phone both use the same profile
526 profile: "phone"
527 Component.onCompleted: load();
528 }
529 }
531 callHint {
532 greeterShown: greeter.shown
533 }
535 readonly property bool topmostApplicationIsFullscreen:
536 ApplicationManager.focusedApplicationId &&
537 ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).fullscreen
539 fullscreenMode: (topmostApplicationIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)
540 || greeter.hasLockedApp
541 locked: greeter && greeter.active
542 }
544 Launcher {
545 id: launcher
546 objectName: "launcher"
548 readonly property bool dashSwipe: progress > 0
550 anchors.top: parent.top
551 anchors.topMargin: inverted ? 0 : panel.panelHeight
552 anchors.bottom: parent.bottom
553 width: parent.width
554 dragAreaWidth: shell.edgeSize
555 available: tutorial.launcherEnabled
556 && (!greeter.locked || AccountsService.enableLauncherWhileLocked)
557 && !greeter.hasLockedApp
558 inverted: shell.usageScenario !== "desktop"
559 shadeBackground: !tutorial.running
561 onShowDashHome: showHome()
562 onDash: showDash()
563 onDashSwipeChanged: {
564 if (dashSwipe) {
565 dash.setCurrentScope(0, false, true)
566 }
567 }
568 onLauncherApplicationSelected: {
569 if (!tutorial.running) {
570 greeter.notifyAboutToFocusApp(appId);
571 shell.activateApplication(appId)
572 }
573 }
574 onShownChanged: {
575 if (shown) {
576 panel.indicators.hide()
577 }
578 }
579 }
581 Wizard {
582 id: wizard
583 objectName: "wizard"
584 anchors.fill: parent
585 background: wallpaperResolver.background
587 function unlockWhenDoneWithWizard() {
588 if (!active) {
589 Connectivity.unlockAllModems();
590 }
591 }
593 Component.onCompleted: unlockWhenDoneWithWizard()
594 onActiveChanged: unlockWhenDoneWithWizard()
595 }
597 Rectangle {
598 id: modalNotificationBackground
600 visible: notifications.useModal
601 color: "#000000"
602 anchors.fill: parent
603 opacity: 0.9
605 MouseArea {
606 anchors.fill: parent
607 }
608 }
610 Notifications {
611 id: notifications
613 model: NotificationBackend.Model
614 margin: units.gu(1)
615 hasMouse: shell.hasMouse
616 background: wallpaperResolver.background
618 y: topmostIsFullscreen ? 0 : panel.panelHeight
619 height: parent.height - (topmostIsFullscreen ? 0 : panel.panelHeight)
621 states: [
622 State {
623 name: "narrow"
624 when: overlay.width <= units.gu(60)
625 AnchorChanges {
626 target: notifications
627 anchors.left: parent.left
628 anchors.right: parent.right
629 }
630 },
631 State {
632 name: "wide"
633 when: overlay.width > units.gu(60)
634 AnchorChanges {
635 target: notifications
636 anchors.left: undefined
637 anchors.right: parent.right
638 }
639 PropertyChanges { target: notifications; width: units.gu(38) }
640 }
641 ]
642 }
643 }
645 Dialogs {
646 id: dialogs
647 objectName: "dialogs"
648 anchors.fill: parent
649 z: overlay.z + 10
650 usageScenario: shell.usageScenario
651 onPowerOffClicked: {
652 shutdownFadeOutRectangle.enabled = true;
653 shutdownFadeOutRectangle.visible = true;
654 shutdownFadeOut.start();
655 }
656 }
658 Connections {
659 target: SessionBroadcast
660 onShowHome: showHome()
661 }
663 ScreenGrabber {
664 id: screenGrabber
665 rotationAngle: -shell.orientationAngle
666 z: dialogs.z + 10
667 }
669 Cursor {
670 id: cursor
671 visible: shell.hasMouse
672 z: screenGrabber.z + 1
674 onPushedLeftBoundary: {
675 if (buttons === Qt.NoButton) {
676 launcher.pushEdge(amount);
677 }
678 }
680 onPushedRightBoundary: {
681 if (buttons === Qt.NoButton && applicationsDisplayLoader.item
682 && applicationsDisplayLoader.item.pushRightEdge) {
683 applicationsDisplayLoader.item.pushRightEdge(amount);
684 }
685 }
687 onMouseMoved: { cursor.opacity = 1; }
688 }
690 Rectangle {
691 id: shutdownFadeOutRectangle
692 z: cursor.z + 1
693 enabled: false
694 visible: false
695 color: "black"
696 anchors.fill: parent
697 opacity: 0.0
698 NumberAnimation on opacity {
699 id: shutdownFadeOut
700 from: 0.0
701 to: 1.0
702 onStopped: {
703 if (shutdownFadeOutRectangle.enabled && shutdownFadeOutRectangle.visible) {
704 DBusUnitySessionService.shutdown();
705 }
706 }
707 }
708 }