git.iko.soy/unity8
on 5ab40fb help sign in
unity8/Components/Stage.qml
540 lines 22 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
22/*
23 Responsible for application switching.
25 Drag from the right edge to switch to the next application.
26 While being dragged, this component will show an animation for the user to
27 visualize that he's changing the stacking of applications (next/new app comes from
28 right edge and current/old app fades out).
29 */
30Showable {
31 id: stage
33 width: units.gu(40)
34 height: units.gu(71)
36 property int type: ApplicationInfo.MainStage
37 property var applicationManager
38 readonly property var applications:
39 type == ApplicationInfo.MainStage ? applicationManager.mainStageApplications
40 : applicationManager.sideStageApplications
41 property bool fullyShown: false
42 readonly property var focusedApplication:
43 type == ApplicationInfo.MainStage ? applicationManager.mainStageFocusedApplication
44 : applicationManager.sideStageFocusedApplication
45 property bool shouldUseScreenshots: true
47 /* Will be true whenever application screenshots are being shown.
48 i.e. during application window transitions */
49 readonly property bool usingScreenshots: {
50 if (newApplicationScreenshot.application != null && oldApplicationScreenshot.application != null) {
51 return newApplicationScreenshot.ready && oldApplicationScreenshot.ready;
52 } else {
53 return newApplicationScreenshot.ready || oldApplicationScreenshot.ready;
54 }
55 }
57 property bool rightEdgeEnabled: true
58 property bool switchingFromFullscreenToFullscreen: false
60 property alias rightEdgeDraggingAreaWidth: rightEdgeDraggingArea.width
62 // Y coordinate for non-fullscreen applications
63 property int normalApplicationY: 0
65 function activateApplication(desktopFile, addDelay) {
66 var application = applicationManager.getApplicationFromDesktopFile(desktopFile, stage.type);
67 if (application != null && application == stage.focusedApplication) {
68 stage.show();
69 return;
70 }
72 showStartingApplicationAnimation.prepare(application);
73 if (!stage.fullyShown) {
74 // if launching this app reveals the stage, make new application screenshot visible
75 newApplicationScreenshot.visible = true;
76 stage.show();
77 } else {
78 showStartingApplicationAnimation.start();
79 }
81 if (addDelay) {
82 stage.__startingApplicationDesktopFile = desktopFile;
83 }
84 }
86 /* Keep a reference to the focused application so that we can safely
87 unfocus it when the stage is not fully shown and refocus it when the stage
88 is fully shown again.
89 */
90 property var focusedApplicationWhenUsingScreenshots
91 onShouldUseScreenshotsChanged: {
92 if (showStartingApplicationAnimation.running || switchToApplicationAnimation.running) {
93 return;
94 }
96 if (shouldUseScreenshots) {
97 stage.__focusApplicationUsingScreenshots(stage.focusedApplication);
98 } else {
99 stage.__focusActualApplication(stage.focusedApplicationWhenUsingScreenshots);
100 }
101 }
104 property Item newApplicationScreenshot: ApplicationScreenshot {
105 parent: stage
106 width: stage.width
107 height: stage.height - y
108 }
109 property Item oldApplicationScreenshot: ApplicationScreenshot {
110 parent: stage
111 width: stage.width
112 height: stage.height - y
113 }
115 function __getApplicationIndex(application) {
116 if (!application)
117 return -1
118 for (var i = 0; i < stage.applications.count; i++ ) {
119 if (stage.applications.get(i).desktopFile == application.desktopFile) {
120 return i
121 }
122 }
123 return -1
124 }
127 property string __startingApplicationDesktopFile
129 Timer {
130 id: delayedHideScreenshots
131 interval: 500 // on Galaxy Nexus, Telephony app is slowest application to draw a frame so needs this delay
132 onTriggered: {
133 __hideScreenshots();
134 }
135 }
137 function __hideScreenshots() {
138 newApplicationScreenshot.clearApplication();
139 oldApplicationScreenshot.clearApplication();
140 newApplicationScreenshot.visible = false;
141 oldApplicationScreenshot.visible = false;
142 }
144 function __focusApplication(application) {
145 if (!application) return
146 if (shouldUseScreenshots) {
147 stage.__focusApplicationUsingScreenshots(application);
148 } else {
149 stage.__focusActualApplication(application);
150 }
151 }
154 function __focusActualApplication(application) {
155 if (application == null) {
156 return;
157 }
159 if (stage.focusedApplication == application) {
160 /* FIXME: this case is reached when showing the sidestage, we
161 need to refocus the side stage app in order to show it.
162 FIXME: this case is reached when doing a right edge swipe
163 while in the dash to bring back the stage.
164 FIXME: this case is reached when showStartingApplicationAnimation
165 finishes after the newly started application has been focused
166 automatically by the ApplicationManager.
167 */
168 if (stage.type == ApplicationInfo.SideStage) {
169 applicationManager.focusApplication(application);
170 }
171 if (!delayedHideScreenshots.running) {
172 stage.__hideScreenshots();
173 }
174 } else {
175 /* FIXME: calling ApplicationManager::focusApplication does not focus
176 the application immediately nor show the application's surface
177 immediately. Delay hiding the screenshots until it has done so.
178 */
179 delayedHideScreenshots.stop();
180 applicationManager.focusApplication(application);
181 }
182 stage.focusedApplicationWhenUsingScreenshots = null;
183 }
185 function __focusApplicationUsingScreenshots(application) {
186 delayedHideScreenshots.stop();
187 if (application == null) {
188 return;
189 }
191 if (newApplicationScreenshot.application != null) {
192 stage.focusedApplicationWhenUsingScreenshots = application;
193 return;
194 }
196 newApplicationScreenshot.setApplication(application);
197 newApplicationScreenshot.scheduleUpdate();
198 newApplicationScreenshot.opacity = 1.0;
199 newApplicationScreenshot.x = 0.0;
200 newApplicationScreenshot.y = __getApplicationY(application);
201 newApplicationScreenshot.scale = 1.0;
202 newApplicationScreenshot.visible = true;
203 stage.focusedApplicationWhenUsingScreenshots = application;
204 stage.switchingFromFullscreenToFullscreen = false;
205 }
207 function __getApplicationY(application) {
208 return Qt.binding( function(){
209 return (application && application.fullscreen
210 && application.stage !== ApplicationInfo.SideStage)
211 ? 0 : normalApplicationY;
212 } )
213 }
215 /* FIXME: should hide the screenshots when the focused application's surface
216 is visible. There is no API in QtUbuntu to support that yet.
217 */
218 Connections {
219 target: stage
220 onFocusedApplicationChanged: {
221 if (stage.focusedApplication != null) {
222 /* Move application to the beginning of the list of running applications */
223 var index = stage.__getApplicationIndex(stage.focusedApplication);
224 applicationManager.moveRunningApplicationStackPosition(index, 0, stage.type);
226 var startingApplication = applicationManager.getApplicationFromDesktopFile(
227 stage.__startingApplicationDesktopFile, stage.type);
229 if (stage.focusedApplication == startingApplication) {
230 stage.__startingApplicationDesktopFile = "";
232 /* Screenshots might still be in use at this point and their
233 use can be stopped before delayedHideScreenshots is complete.
234 Prepare for that case by setting appropriately
235 stage.focusedApplicationWhenUsingScreenshots.
236 */
237 stage.focusedApplicationWhenUsingScreenshots = stage.focusedApplication;
239 /* FIXME: should hide the screenshots when the focused application's window
240 is visible. There is no API in qtubuntu to support that yet. Therefore
241 we delay their hiding to avoid a state where neither the screenshot nor
242 the application's window is visible.
243 */
244 delayedHideScreenshots.start();
245 } else {
246 stage.__hideScreenshots();
247 }
248 }
249 }
250 }
253 SequentialAnimation {
254 id: showStartingApplicationAnimation
256 function prepare(newApplication) {
257 var oldApplication = stage.focusedApplication;
258 newApplicationScreenshot.setApplication(newApplication);
259 newApplicationScreenshot.updateFromCache();
260 oldApplicationScreenshot.setApplication(oldApplication);
261 oldApplicationScreenshot.scheduleUpdate();
262 newApplicationScreenshot.withBackground = true; // FIXME: should be withBackground = newApplication.state == Application.Starting
263 newApplicationScreenshot.y = __getApplicationY(newApplication);
264 oldApplicationScreenshot.y = __getApplicationY(oldApplication);
265 stage.focusedApplicationWhenUsingScreenshots = newApplication;
266 stage.switchingFromFullscreenToFullscreen = false;
267 }
269 PropertyAction {target: newApplicationScreenshot; property: "visible"; value: false}
270 PropertyAction {target: oldApplicationScreenshot; property: "visible"; value: false}
271 PropertyAction {target: newApplicationScreenshot; property: "z"; value: 0}
272 PropertyAction {target: oldApplicationScreenshot; property: "z"; value: 1}
273 PropertyAction {target: newApplicationScreenshot; property: "scale"; value: 0.8}
274 PropertyAction {target: oldApplicationScreenshot; property: "scale"; value: 1.0}
275 PropertyAction {target: newApplicationScreenshot; property: "opacity"; value: 0.0}
276 PropertyAction {target: oldApplicationScreenshot; property: "opacity"; value: 1.0}
277 PropertyAction {target: newApplicationScreenshot; property: "x"; value: 0.0}
278 PropertyAction {target: oldApplicationScreenshot; property: "x"; value: 0.0}
280 ParallelAnimation {
281 PropertyAction {target: newApplicationScreenshot; property: "visible"; value: true}
282 NumberAnimation {
283 target: newApplicationScreenshot
284 property: "scale"
285 duration: 500
286 easing.type: Easing.OutQuad
287 to: 1.0
288 }
289 NumberAnimation {
290 target: newApplicationScreenshot
291 property: "opacity"
292 duration: 500
293 easing.type: Easing.OutQuad
294 to: 1.0
295 }
297 PropertyAction {target: oldApplicationScreenshot; property: "visible"; value: true}
299 NumberAnimation {
300 target: oldApplicationScreenshot
301 property: "x"
302 duration: 400
303 easing.type: Easing.OutQuad
304 to: stage.width
305 }
306 }
308 ScriptAction {
309 script: {
310 if (!stage.focusedApplicationWhenUsingScreenshots) {
311 // FIXME: only here to support case where application does
312 // not exist yet but is about to
313 return;
314 }
316 stage.__focusApplication(stage.focusedApplicationWhenUsingScreenshots);
317 }
318 }
319 }
322 SequentialAnimation {
323 id: switchToApplicationAnimation
325 function prepare(newApplication) {
326 var oldApplication = stage.focusedApplication;
327 newApplicationScreenshot.setApplication(newApplication);
328 newApplicationScreenshot.updateFromCache();
329 oldApplicationScreenshot.setApplication(oldApplication);
330 oldApplicationScreenshot.scheduleUpdate();
331 newApplicationScreenshot.withBackground = false;
332 newApplicationScreenshot.y = __getApplicationY(newApplication);
333 oldApplicationScreenshot.y = __getApplicationY(oldApplication);
334 stage.focusedApplicationWhenUsingScreenshots = newApplication;
335 stage.switchingFromFullscreenToFullscreen = newApplication && newApplication.fullscreen;
336 }
338 PropertyAction {target: newApplicationScreenshot; property: "visible"; value: false}
339 PropertyAction {target: oldApplicationScreenshot; property: "visible"; value: false}
340 PropertyAction {target: newApplicationScreenshot; property: "z"; value: 1}
341 PropertyAction {target: oldApplicationScreenshot; property: "z"; value: 0}
342 PropertyAction {target: newApplicationScreenshot; property: "scale"; value: 1.0}
343 PropertyAction {target: oldApplicationScreenshot; property: "scale"; value: 1.0}
344 PropertyAction {target: newApplicationScreenshot; property: "opacity"; value: 1.0}
345 PropertyAction {target: oldApplicationScreenshot; property: "opacity"; value: 1.0}
346 PropertyAction {target: newApplicationScreenshot; property: "x"; value: stage.width}
347 PropertyAction {target: oldApplicationScreenshot; property: "x"; value: 0.0}
348 PropertyAction {target: newApplicationScreenshot; property: "visible"; value: true}
349 PropertyAction {target: oldApplicationScreenshot; property: "visible"; value: true}
351 ParallelAnimation {
352 NumberAnimation {
353 target: oldApplicationScreenshot
354 property: "scale"
355 duration: 500
356 easing.type: Easing.OutQuad
357 to: 0.8
358 }
359 NumberAnimation {
360 target: oldApplicationScreenshot
361 property: "opacity"
362 duration: 500
363 easing.type: Easing.OutQuad
364 to: 0.0
365 }
367 NumberAnimation {
368 target: newApplicationScreenshot
369 property: "x"
370 duration: 500
371 easing.type: Easing.OutQuad
372 to: 0
373 }
374 }
376 ScriptAction {
377 script: {
378 // move previously focused application to the end of the list of running applications
379 var oldApplication = oldApplicationScreenshot.application;
380 if (oldApplication != null) {
381 var oldApplicationIndex = stage.__getApplicationIndex(oldApplicationScreenshot.application);
382 applicationManager.moveRunningApplicationStackPosition(
383 oldApplicationIndex, stage.applications.count - 1, stage.type);
384 }
386 stage.__focusApplication(stage.focusedApplicationWhenUsingScreenshots);
387 }
388 }
389 }
392 function __dragValueToProgress(dragValue, startValue, applicationsCount) {
393 if (applicationsCount == 0) {
394 return 0;
395 } else if (applicationsCount == 1) {
396 // prevent the current app from moving more than 1/4 of the screen
397 var elasticValue = __elastic(dragValue, startValue/4);
398 return elasticValue / startValue;
399 } else {
400 return dragValue / startValue;
401 }
402 }
404 function __elastic(x, limit) {
405 return limit * ( 1 - Math.pow( ( limit - 1 ) / limit, x ) )
406 }
408 property real __startValue: stage.width
410 AnimationControllerWithSignals {
411 id: switchToApplicationAnimationController
413 onAnimationCompletedAtBeginning: {
414 animation = null;
415 stage.__focusApplication(oldApplicationScreenshot.application);
416 }
417 }
419 EdgeDragEvaluator {
420 id: dragEvaluator
421 trackedPosition: rightEdgeDraggingArea.touchX
422 direction: rightEdgeDraggingArea.direction
423 maxDragDistance: stage.width
424 }
426 EdgeDragArea {
427 id: rightEdgeDraggingArea
429 enabled: {
430 if (status == DirectionalDragArea.WaitingForTouch) {
431 return switchToApplicationAnimationController.completed
432 && stage.applications.count > 0 && stage.rightEdgeEnabled
433 && !delayedHideScreenshots.running
434 } else {
435 return true
436 }
437 }
438 width: units.gu(2)
439 anchors.top: parent.top
440 anchors.bottom: parent.bottom
441 anchors.right: parent.right
443 direction: Direction.Leftwards
445 onDistanceChanged: {
446 if (status !== DirectionalDragArea.Recognized)
447 return
449 var targetProgress = __dragValueToProgress(-distance, __startValue,
450 stage.applications.count)
451 var delta = targetProgress - switchToApplicationAnimationController.progress
453 // When the gesture finally gets recognized, the finger will likely be
454 // reasonably far from the edge. If we made the progress immediately
455 // follow the finger position it would be visually unpleasant as there
456 // would be a jump to meet the finger's current position.
457 //
458 // The trick is not to go all the way (1.0) as it would cause the
459 // aforementioned jump.
460 switchToApplicationAnimationController.progress += 0.4 * delta
461 }
463 property bool gotRejected: false
465 onStatusChanged: {
466 if (status == DirectionalDragArea.Undecided) {
467 gotRejected = false
468 onUndecided();
469 } else if (status == DirectionalDragArea.Rejected) {
470 switchToApplicationAnimationController.completeToBeginningWithSignal();
471 gotRejected = true;
472 } else if (status == DirectionalDragArea.WaitingForTouch) {
473 if (!gotRejected)
474 onGestureEnded()
475 }
476 }
478 function onUndecided() {
479 dragEvaluator.reset();
481 var nextApplication = null;
482 if (stage.applications.count > 1) {
483 nextApplication = stage.applications.get(1);
484 }
485 switchToApplicationAnimationController.progress = 0
486 switchToApplicationAnimation.prepare(nextApplication);
487 switchToApplicationAnimationController.animation = switchToApplicationAnimation;
489 }
491 function onGestureEnded() {
492 if (stage.applications.count > 1 && dragEvaluator.shouldAutoComplete()) {
493 switchToApplicationAnimationController.completeToEndWithSignal();
494 } else {
495 switchToApplicationAnimationController.completeToBeginningWithSignal();
496 }
497 }
498 }
501 // FIXME: very bad hack to detect when an application was closed or crashed
502 property var __previouslyFocusedApplication
503 Connections {
504 target: stage
505 onFocusedApplicationChanged: {
506 if (stage.focusedApplication == null
507 && __getApplicationIndex(stage.__previouslyFocusedApplication) == -1) {
508 stage.__onFocusedApplicationClosed();
509 }
510 stage.__previouslyFocusedApplication = stage.focusedApplication;
511 }
512 }
514 function __onFocusedApplicationClosed() {
515 if (!stage.shown) {
516 return;
517 }
519 if (stage.applications.count > 0) {
520 // Do not change the focused application from within onFocusedApplicationChanged.
521 // This causes binding loop warnings besides being a bad practice in general
522 // (setting a property from within its "changed" signal handling)
523 // Hence the timer.
524 focusTopmostAppTimer.start();
525 } else {
526 stage.hide();
527 }
528 }
530 Timer {
531 id: focusTopmostAppTimer
532 interval: 1; repeat: false
533 onTriggered: {
534 if (stage.applications.count > 0) {
535 stage.__focusApplication(stage.applications.get(0));
536 }
537 }
538 }