8e838d6 · unity8 · git.iko.soy

340 model: ApplicationManager

341

342 Item {

343+ id: appItem

343 height: parent.height

344 height: parent.height

344 width: coverFlip.tileWidth

345 width: coverFlip.tileWidth

345

346

346− Image {

347− id: appImage

348− anchors { left: parent.left; bottom: parent.bottom }

349− width: root.width

350− source: ApplicationManager.get(index).screenshot

351− scale: 1

352−

353− // This is the main progress, of the gesture, the same for every tile

347+ // This is the main progress, of the gesture, the same for every tile

354− property real progress: coverFlip.progress

348+ property real progress: coverFlip.progress

355− // The progress, translated for the second stage of the animation, after the first app switch has happened

349+ // The progress, translated for the second stage of the animation, after the first app switch has happened

356− // Additionally it speeds it up a bit, depending on the distance of the tile

350+ // Additionally it speeds it up a bit, depending on the distance of the tile

357− property real translatedProgress: appImage.progress - coverFlip.progressMarker1 - (coverFlip.tileDistance * (index-1))

351+ property real translatedProgress: appItem.progress - coverFlip.progressMarker1 - (coverFlip.tileDistance * (index-1))

358−

352+

359− // Is this tile selected by a click?

353+ // Is this tile selected by a click?

360− property bool isSelected: false

354+ property bool isSelected: false

361− // We need to remember some values when app is selected to be able to animate it to the foreground

355+ // We need to remember some values when app is selected to be able to animate it to the foreground

362− property real selectedXTranslation: 0

356+ property real selectedXTranslation: 0

363− property real selectedTranslatedProgress: 0

357+ property real selectedTranslatedProgress: 0

364− property real selectedProgress: 0

358+ property real selectedProgress: 0

365− property real selectedAngle: 0

359+ property real selectedAngle: 0

366− property real selectedXScale: 0

360+ property real selectedXScale: 0

367−

361+

368− function select() {

362+ function select() {

369− appImage.selectedXTranslation = appImage.xTranslation;

363+ appItem.selectedXTranslation = appItem.xTranslation;

370− appImage.selectedAngle = appImage.angle;

364+ appItem.selectedAngle = appItem.angle;

371− appImage.selectedXScale = appImage.xScale;

365+ appItem.selectedXScale = appItem.xScale;

372− appImage.selectedTranslatedProgress = appImage.translatedProgress - coverFlip.progressMarker1;

366+ appItem.selectedTranslatedProgress = appItem.translatedProgress - coverFlip.progressMarker1;

373− appImage.selectedProgress = appImage.progress - coverFlip.progressMarker1;

367+ appItem.selectedProgress = appItem.progress - coverFlip.progressMarker1;

374− appImage.isSelected = true;

368+ appItem.isSelected = true;

375− switchToAppAnimation.targetContentX = coverFlip.progressMarker1 * root.width

369+ switchToAppAnimation.targetContentX = coverFlip.progressMarker1 * root.width

376− switchToAppAnimation.start();

370+ switchToAppAnimation.start();

377− }

371+ }

378

372

379− property int xTranslation: {

373+ property int xTranslation: {

380− var xTranslate = 0;

374+ var xTranslate = 0;

381− var minXTranslate = -index * root.width + index * units.dp(3);

375+ var minXTranslate = -index * root.width + index * units.dp(3);

382− switch (index) {

376+ switch (index) {

383− case 0:

377+ case 0:

384− if (appImage.progress < coverFlip.progressMarker1) {

378+ if (appItem.progress < coverFlip.progressMarker1) {

385− var progress = appImage.progress

379+ var progress = appItem.progress

386− var progressDiff = coverFlip.progressMarker1

380+ var progressDiff = coverFlip.progressMarker1

387− var translateDiff = -root.width * 0.25

381+ var translateDiff = -root.width * 0.25

388− // progress : progressDiff = translate : translateDiff

382+ // progress : progressDiff = translate : translateDiff

389− xTranslate = progress * translateDiff / progressDiff

383+ xTranslate = progress * translateDiff / progressDiff

390− }

384+ }

385+ break;

386+ case 1:

387+ if (appItem.progress < coverFlip.progressMarker1) {

388+ var progress = appItem.progress;

389+ var progressDiff = coverFlip.progressMarker1;

390+ var translateDiff = -root.width;

391+ // progress : progressDiff = translate : translateDiff

392+ xTranslate = progress * translateDiff / progressDiff;

391 break;

393 break;

392− case 1:

394+ }

395+ // Intentionally no break here...

396+ default:

393− if (appImage.progress < coverFlip.progressMarker1) {

397+ if (appItem.progress > coverFlip.progressMarker1) {

394− var progress = appImage.progress;

398+ xTranslate = xTranslateEasing.value * xTranslateEasing.period;

395− var progressDiff = coverFlip.progressMarker1;

399+ if (appItem.isSelected) {

396− var translateDiff = -root.width;

400+ var translateDiff = root.width * index + appItem.selectedXTranslation

401+ var progressDiff = appItem.selectedProgress

402+ var progress = progressDiff - (appItem.progress - coverFlip.progressMarker1);

397 // progress : progressDiff = translate : translateDiff

403 // progress : progressDiff = translate : translateDiff

398− xTranslate = progress * translateDiff / progressDiff;

399− break;

400− }

401− // Intentionally no break here...

402− default:

403− if (appImage.progress > coverFlip.progressMarker1) {

404− xTranslate = xTranslateEasing.value * xTranslateEasing.period;

405− if (appImage.isSelected) {

406− var translateDiff = root.width * index + appImage.selectedXTranslation

407− var progressDiff = appImage.selectedProgress

408− var progress = progressDiff - (appImage.progress - coverFlip.progressMarker1);

409− // progress : progressDiff = translate : translateDiff

410− var newTranslate = progress * translateDiff / progressDiff;

404+ var newTranslate = progress * translateDiff / progressDiff;

411−

405+

412− xTranslate = appImage.selectedXTranslation - newTranslate;

406+ xTranslate = appItem.selectedXTranslation - newTranslate;

413− }

414− break;

415 }

407 }

408+ break;

416 }

409 }

417− return xTranslate;

418 }

410 }

411+ return xTranslate;

412+ }

419

413

420− property real angle: {

414+ property real angle: {

421− var newAngle = 0;

415+ var newAngle = 0;

422− switch (index) {

416+ switch (index) {

423− case 0:

417+ case 0:

424− if (appImage.progress < coverFlip.progressMarker1) {

418+ if (appItem.progress < coverFlip.progressMarker1) {

425− var progress = appImage.progress;

419+ var progress = appItem.progress;

426− var angleDiff = coverFlip.endAngle;

420+ var angleDiff = coverFlip.endAngle;

427− var progressDiff = coverFlip.progressMarker1;

421+ var progressDiff = coverFlip.progressMarker1;

428− // progress : progressDiff = angle : angleDiff

422+ // progress : progressDiff = angle : angleDiff

429− newAngle = progress * angleDiff / progressDiff;

423+ newAngle = progress * angleDiff / progressDiff;

430− } else {

424+ } else {

431− var progress = appImage.progress - coverFlip.progressMarker1;

425+ var progress = appItem.progress - coverFlip.progressMarker1;

432− var angleDiff = coverFlip.endAngle;

426+ var angleDiff = coverFlip.endAngle;

433− var progressDiff = 1 - coverFlip.progressMarker1;

427+ var progressDiff = 1 - coverFlip.progressMarker1;

434− // progress : progressDiff = angle : angleDiff

428+ // progress : progressDiff = angle : angleDiff

435− newAngle = progress * angleDiff / progressDiff;

429+ newAngle = progress * angleDiff / progressDiff;

436− newAngle = Math.min(coverFlip.endAngle, newAngle);

430+ newAngle = Math.min(coverFlip.endAngle, newAngle);

437− }

431+ }

432+ break;

433+ case 1:

434+ if (appItem.progress < coverFlip.progressMarker1) {

435+ var progress = coverFlip.progress;

436+ var angleDiff = coverFlip.startAngle;

437+ var progressDiff = coverFlip.progressMarker1;

438+ // progress : progressDiff = angle : angleDiff

439+ var angle = progress * angleDiff / progressDiff;

440+ newAngle = coverFlip.startAngle - angle;

438 break;

441 break;

439− case 1:

440− if (appImage.progress < coverFlip.progressMarker1) {

441− var progress = coverFlip.progress;

442− var angleDiff = coverFlip.startAngle;

443− var progressDiff = coverFlip.progressMarker1;

444− // progress : progressDiff = angle : angleDiff

445− var angle = progress * angleDiff / progressDiff;

446− newAngle = coverFlip.startAngle - angle;

447− break;

448− }

442+ }

449− // Intentionally no break here...

443+ // Intentionally no break here...

450− default:

444+ default:

451− newAngle = coverFlip.startAngle - (angleEasing.value * angleEasing.period);

445+ newAngle = coverFlip.startAngle - (angleEasing.value * angleEasing.period);

452− // make sure we stop at the left screen edge

446+ // make sure we stop at the left screen edge

453− newAngle = Math.max(newAngle, coverFlip.endAngle);

447+ newAngle = Math.max(newAngle, coverFlip.endAngle);

454

448

455− if (appImage.isSelected) {

449+ if (appItem.isSelected) {

456// var selectedAngleTranslate = selectedAngleEasing.value * selectedAngleEasing.period

450// var selectedAngleTranslate = selectedAngleEasing.value * selectedAngleEasing.period

457− var angleDiff = appImage.selectedAngle

451+ var angleDiff = appItem.selectedAngle

458− var progressDiff = appImage.selectedProgress

452+ var progressDiff = appItem.selectedProgress

459− var progress = progressDiff - (appImage.progress - coverFlip.progressMarker1);

453+ var progress = progressDiff - (appItem.progress - coverFlip.progressMarker1);

460− // progress : progressDiff = angle : angleDiff

454+ // progress : progressDiff = angle : angleDiff

461− var selectedAngleTranslate = progress * angleDiff / progressDiff;

455+ var selectedAngleTranslate = progress * angleDiff / progressDiff;

462

456

463− newAngle = appImage.selectedAngle - selectedAngleTranslate;

457+ newAngle = appItem.selectedAngle - selectedAngleTranslate;

464− }

465 }

458 }

466− return newAngle;

467 }

459 }

460+ return newAngle;

461+ }

468

462

469− property real xScale: {

463+ property real xScale: {

470− var scale = 1;

464+ var scale = 1;

471

465

472− switch (index) {

466+ switch (index) {

473− case 0:

467+ case 0:

474− if (appImage.progress > coverFlip.progressMarker1) {

468+ if (appItem.progress > coverFlip.progressMarker1) {

475− var scaleDiff = coverFlip.maxScale - 1;

469+ var scaleDiff = coverFlip.maxScale - 1;

476− var progressDiff = 1.5 - coverFlip.progressMarker1;

470+ var progressDiff = 1.5 - coverFlip.progressMarker1;

477− // progress : progressDiff = scale : scaleDiff

471+ // progress : progressDiff = scale : scaleDiff

478− scale = 1 - (appImage.progress - coverFlip.progressMarker1) * scaleDiff / progressDiff;

472+ scale = 1 - (appItem.progress - coverFlip.progressMarker1) * scaleDiff / progressDiff;

479− }

473+ }

474+ break;

475+ case 1:

476+ if (appItem.progress < coverFlip.progressMarker1) {

477+ var scaleDiff = coverFlip.maxScale - 1

478+ var progressDiff = coverFlip.progressMarker1

479+ // progress : progressDiff = scale : scaleDiff

480+ scale = coverFlip.maxScale - (appItem.progress * scaleDiff / progressDiff);

480 break;

481 break;

481− case 1:

482− if (appImage.progress < coverFlip.progressMarker1) {

483− var scaleDiff = coverFlip.maxScale - 1

484− var progressDiff = coverFlip.progressMarker1

485− // progress : progressDiff = scale : scaleDiff

486− scale = coverFlip.maxScale - (appImage.progress * scaleDiff / progressDiff);

487− break;

488− }

489− // Intentionally no break

490− default:

491− scale = coverFlip.maxScale - scaleEasing.value * scaleEasing.period;

492− if (appImage.isSelected) {

493− var scaleDiff = -(1 - appImage.selectedXScale)

494− var progressDiff = appImage.selectedProgress

495− var progress = progressDiff - (appImage.progress - coverFlip.progressMarker1);

496− // progress : progressDiff = angle : angleDiff

497− var selectedScaleTranslate = progress * scaleDiff / progressDiff;

498−

499− scale = appImage.selectedXScale - selectedScaleTranslate;

500− }

501 }

482 }

502− return Math.min(coverFlip.maxScale, Math.max(coverFlip.minScale, scale));

483+ // Intentionally no break

484+ default:

485+ scale = coverFlip.maxScale - scaleEasing.value * scaleEasing.period;

486+ if (appItem.isSelected) {

487+ var scaleDiff = -(1 - appItem.selectedXScale)

488+ var progressDiff = appItem.selectedProgress

489+ var progress = progressDiff - (appItem.progress - coverFlip.progressMarker1);

490+ // progress : progressDiff = angle : angleDiff

491+ var selectedScaleTranslate = progress * scaleDiff / progressDiff;

492+

493+ scale = appItem.selectedXScale - selectedScaleTranslate;

494+ }

503 }

495 }

496+ return Math.min(coverFlip.maxScale, Math.max(coverFlip.minScale, scale));

497+ }

504

498

505− EasingCurve {

499+ EasingCurve {

506− id: xTranslateEasing

500+ id: xTranslateEasing

507− type: EasingCurve.OutQuad

501+ type: EasingCurve.OutQuad

508− period: index * -width

502+ period: index * -width

509− progress: appImage.translatedProgress

503+ progress: appItem.translatedProgress

510− }

504+ }

511− EasingCurve {

505+ EasingCurve {

512− id: angleEasing

506+ id: angleEasing

513− type: EasingCurve.InQuad

507+ type: EasingCurve.InQuad

514− period: coverFlip.startAngle - coverFlip.endAngle

508+ period: coverFlip.startAngle - coverFlip.endAngle

515− progress: appImage.translatedProgress

509+ progress: appItem.translatedProgress

516− }

510+ }

517− EasingCurve {

511+ EasingCurve {

518− id: scaleEasing

512+ id: scaleEasing

519− type: EasingCurve.Linear

513+ type: EasingCurve.Linear

520− period: coverFlip.maxScale - coverFlip.minScale

514+ period: coverFlip.maxScale - coverFlip.minScale

521− progress: appImage.translatedProgress

515+ progress: appItem.translatedProgress

522− }

516+ }

523

517

524− transform: [

518+ transform: [

525− Rotation {

519+ Rotation {

526− origin { x: 0; y: coverFlip.height / 2 }

520+ origin { x: 0; y: coverFlip.height / 2 }

527− axis { x: 0; y: 1; z: 0 }

521+ axis { x: 0; y: 1; z: 0 }

528− angle: appImage.angle

522+ angle: appItem.angle

529− },

523+ },

530− Translate {

524+ Translate {

531− x: appImage.xTranslation

525+ x: appItem.xTranslation

532− },

526+ },

533− Scale {

527+ Scale {

534− origin { x: appImage.xTranslation; y: root.height / 2 - (root.height - appImage.height)}

528+ origin { x: appItem.xTranslation; y: root.height / 2 - (root.height - appImage.height)}

535− xScale: appImage.xScale

529+ xScale: appItem.xScale

536− yScale: xScale

530+ yScale: xScale

537− }

531+ }

538− ]

532+ ]

539

533

534+ Image {

535+ id: dropShadow

536+ anchors.fill: appImage

537+ anchors.margins: -units.gu(2)

538+ source: "graphics/dropshadow.png"

539+ }

540+ Image {

541+ id: appImage

542+ anchors { left: parent.left; bottom: parent.bottom }

543+ width: root.width

544+ source: ApplicationManager.get(index).screenshot

545+ scale: 1

546+ }

540− MouseArea {

547+ MouseArea {

541− anchors.fill: parent

548+ anchors.fill: parent

542− onClicked: {

549+ onClicked: {

543− appImage.select()

550+ appItem.select()

544− }

545 }

551 }

546 }

552 }

547

553

557 ScriptAction {

563 ScriptAction {

558 script: {

564 script: {

559 ApplicationManager.focusApplication(ApplicationManager.get(index).appId);

565 ApplicationManager.focusApplication(ApplicationManager.get(index).appId);

560− appImage.isSelected = false;

566+ appItem.isSelected = false;

561 coverFlip.progress = 0;

567 coverFlip.progress = 0;

562 coverFlickable.passedFirstStage = false;

568 coverFlickable.passedFirstStage = false;

563 }

569 }