~josephjamesmills/ubuntutv/maps_fanart

/*
 * This file is part of unity-2d
 *
 * Copyright 2010-2011 Canonical Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import QtQuick 1.1
import Unity2d 1.0
import Effects 1.0
import "../common"
import "../indicators"
import "../sidebar"
import "../common/units.js" as Units

FocusScope {
    id: dash
    Accessible.name: "dash"

    LayoutMirroring.enabled: isRightToLeft()
    LayoutMirroring.childrenInherit: true

    property variant currentPage

    /* FIXME: 'active' property exactly mirrors 'declarativeView.dashActive'.
       The final goal is to transition to using exclusively the QML 'active' property
       and drop the C++ 'declarativeView.dashActive'.
    */

    property variant active
    property bool epgActive: false
   // property bool itvActive: false
    /* The following way of mirroring the values of 'declarativeView.dashActive'
       and 'active' works now and QML does not see it as a binding loop but we
       cannot count on it long term.
    */
    Binding {
        target: declarativeView
        property: "dashActive"
        value: dash.active
    }
    Binding {
        target: dash
        property: "active"
        value: declarativeView.dashActive
    }

    /* Unload the current page when closing the dash */
    onActiveChanged: {
        /* FIXME find a better way to hide the preview when disactivating the dash */
        if (!dash.active && previewer.active) delayHidePreview.restart()
        if (!dash.active && unity2dConfiguration.formFactor != "tv") {
            /* FIXME: currentPage needs to stop pointing to pageLoader.item
                      that is about to be invalidated otherwise a crash
                      occurs because SearchEntry has a binding that refers
                      to currentPage and tries to access it.
               Ref.: https://bugs.launchpad.net/ubuntu/+source/unity-2d/+bug/817896
                     https://bugreports.qt.nokia.com/browse/QTBUG-20692
            */
            deactivateActiveLens()
            currentPage = undefined
            // Delay the following instruction by 1 millisecond using a
            // timer. This is enough to work around a crash that happens
            // when the layout is mirrored (RTL locales). See QTBUG-22776
            // for details.
            //pageLoader.source = ""
            delayPageLoaderReset.restart()
        }
    }

    Timer {
        id: delayPageLoaderReset
        interval: 1
        onTriggered: pageLoader.setSource("")
    }

    Timer {
        id: delayHidePreview
        interval: 500
        onTriggered: hidePreview()
    }

    function isRightToLeft() {
        return Qt.application.layoutDirection == Qt.RightToLeft
    }

    property string startupLens: unity2dConfiguration.formFactor == "tv" ? "video.lens" : ""

    Connections {
        target: lenses
        onLoaded: if (startupLens) activateLens(startupLens)
    }

    Binding {
        target: declarativeView
        property: "expanded"
        value: (currentPage && currentPage.expanded != undefined) ? currentPage.expanded : true
    }

    DashSettings {
        id: dashSettings
    }

    Binding {
        target: declarativeView
        property: "dashMode"
        value: (dashSettings.formFactor == DashSettings.Desktop) ?
               ShellDeclarativeView.DesktopMode : ShellDeclarativeView.FullScreenMode
    }

    Connections {
        target: declarativeView

        onActivateHome: activateHome()
        onActivateLens: activateLens(lensId)
    }

    function edgeEvent(event) {
        if (unity2dConfiguration.formFactor == "tv"
            && (event.key == Qt.Key_F3 || event.key == Qt.Key_MediaPlay)
            && declarativeView.activeLens != ""
            && !previewer.active) {
                if (!sidebar.activeFocus) {
                    sidebar.forceActiveFocus()
                } else {
                    sidebar.focus = false
                    dash.forceActiveFocus()
                }
                event.accepted = true
        }
    }

    function activatePage(page) {
        /* Always give the focus to the search entry when switching pages */
        search_entry.focus = true

        if (page == currentPage) {
            return
        }

        if (currentPage != undefined) {
            currentPage.visible = false
        }
        currentPage = page
        currentPage.visible = true
    }

    function deactivateActiveLens() {
        epgActive = false
        if (previewer.active) hidePreview()
        if (declarativeView.activeLens != "") {
            var lens = lenses.get(declarativeView.activeLens)
            lens.active = false
        }
        declarativeView.activeLens = ""
    }

   /* function deactivateActiveLens() {
        itvActive = false
        if (previewer.active) hidePreview()
        if (declarativeView.activeLens != "") {
            var lens = lenses.get(declarativeView.activeLens)
            lens.active = false
        }
        declarativeView.activeLens = ""
    }
*/
    function activateLens(lensId) {
        if (lensId == declarativeView.activeLens) {
            dash.active = true
            return
        }

        deactivateActiveLens()
        var lens = lenses.get(lensId)
        if (lens == null) {
            console.log("No match for lens: %1".arg(lensId))
            return
        }

        lens.active = true
        declarativeView.activeLens = lens.id
        dash.active = true
        pageLoader.setSource("LensView.qml")
        /* Take advantage of the fact that the loaded qml is local and setting
           the source loads it immediately making pageLoader.item valid */
        pageLoader.item.model = lens
        activatePage(pageLoader.item)
    }

    function activateHome() {
        deactivateActiveLens()
        pageLoader.setSource("Home.qml")
        /* Take advantage of the fact that the loaded qml is local and setting
           the source loads it immediately making pageLoader.item valid */
        activatePage(pageLoader.item)
        declarativeView.activeLens = ""
        dash.active = true
    }

    function activateEPG() {
        deactivateActiveLens()
        epgActive = true
        pageLoader.setSource("EPG.qml")
        activatePage(pageLoader.item)
        declarativeView.activeLens = ""
        dash.active = true
    }

    /*function activateITV() {
        deactivateActiveLens()
        itvActive = true
        pageLoader.setSource("ITV.qml")
        activatePage(pageLoader.item)
        declarativeView.activeLens = ""
        dash.active = true
    }
*/
    function activateLensWithOptionFilter(lensId, filterId, optionId) {
        var lens = lenses.get(lensId)
        var filter = lens.filters.getFilter(filterId)
        var option = filter.getOption(optionId)
        filter.clear()
        option.active = true
        filterPane.folded = false
        activateLens(lensId)
    }

    function activateLensAndClearFilter(lensId, filterId) {
        var lens = lenses.get(lensId)
        var filter = lens.filters.getFilter(filterId)
        filter.clear()
        activateLens(lensId)
    }

    function activateUriWithLens(lens, category, uri, mimetype) {
        /* FIXME: need a reliable way to make the dash player intercept
                  content that is should playback */
        if (unity2dConfiguration.formFactor == "tv" && mimetype.indexOf("video/") == 0) {
            var cleanUri = decodeURIComponent(uri.substring(uri.indexOf(":")+1))
            if (lens.id == "video.lens") {
                showPreview(category, cleanUri, mimetype)
            } else {
                shell.play(cleanUri)
            }
        } else {
            if (unity2dConfiguration.formFactor == "desktop") {
                dash.active = false
            }
            lens.activate(decodeURIComponent(uri))
        }
    }

    function activateApplication(application) {
        if (unity2dConfiguration.formFactor == "desktop") {
            dash.active = false
        }
        application.activate()
    }

    property variant lenses: Lenses {}

    /* Previewer */
    function showPreview(category, uri, mimeType){
        previewer.category = category
        previewer.uri = uri
        previewer.mimeType = mimeType
        previewer.active = true
        previewer.focus = true
    }

    function hidePreview() {
        if (!previewer.active) return
        previewer.active = false
        pageLoader.focus = true
        previewer.uri = ""
        previewer.mimeType = ""
    }

    Item {
        id: background

        property bool transparent: unity2dConfiguration.formFactor == "desktop"
        visible: background.transparent
        anchors.fill: parent

        /* Avoid redraw at rendering */
        effect: CacheEffect {}

        Item {
            anchors.fill: parent
            anchors.bottomMargin: content.anchors.bottomMargin
            anchors.rightMargin: content.anchors.rightMargin
            clip: true

            Image {
                id: blurredBackground

                effect: Blur {blurRadius: 12}

                /* 'source' needs to be set when the dash becomes visible, that
                   is when dash.active becomes true, so that a
                   screenshot of the windows behind the dash is taken at that
                   point.
                   'source' also needs to change so that the screenshot is
                   re-taken as opposed to pulled from QML's image cache.
                   This workarounds the fact that the image cache cannot be
                   disabled. A new API to deal with this was introduced in Qt Quick 1.1.

                   See http://doc.qt.nokia.com/4.7-snapshot/qml-image.html#cache-prop
                */
                property variant timeAtActivation
                Connections {
                    target: dash
                    onActiveChanged: blurredBackground.timeAtActivation = screen.currentTime()
                }

                /* Use an image of the root window which essentially is a
                   capture of the entire screen */
                source: if (background.transparent) {
                            return dash.active ? "image://window/root@" + blurredBackground.timeAtActivation : ""
                        } else {
                            return ""
                        }

                fillMode: Image.PreserveAspectCrop
                x: -launcherLoader.width
                y: -declarativeView.globalPosition.y
            }

            Image {
                anchors.fill: parent
                fillMode: Image.PreserveAspectCrop
                source: background.transparent ? "artwork/background_sheen.png" : ""
            }
        }

        BorderImage {
            anchors.fill: parent
            visible: declarativeView.dashMode == ShellDeclarativeView.DesktopMode
            source: screen.isCompositingManagerRunning ? "artwork/desktop_dash_background.sci" : "artwork/desktop_dash_background_no_transparency.sci"
            mirror: isRightToLeft()
        }
    }

    FocusScope {
        id: content

        focus: true

        anchors.fill: parent
        /* Margins in DesktopMode set so that the content does not overlap with
           the border defined by the background image.
        */
        anchors.bottomMargin: declarativeView.dashMode == ShellDeclarativeView.DesktopMode ? 39 : 0
        anchors.rightMargin: declarativeView.dashMode == ShellDeclarativeView.DesktopMode ? 37 : 0

        /* Unhandled keys will always be forwarded to the search bar. That way
           the user can type and search from anywhere in the interface without
           necessarily focusing the search bar first. */
        /* FIXME: deactivated because it makes the user lose the focus very often */
        //Keys.forwardTo: [search_entry]

        Behavior on opacity { NumberAnimation { duration: 250 } }

        SearchEntry {
            id: search_entry

            focus: true
            /* FIXME: check on visible necessary; fixed in Qt Quick 1.1
                      ref: http://bugreports.qt.nokia.com/browse/QTBUG-15862
            */
            KeyNavigation.right: {
                if (unity2dConfiguration.formFactor == "desktop") return filterPane.visible ? filterPane : search_entry
                else if (unity2dConfiguration.formFactor == "tv") return indicators
                else return search_entry
            }
            KeyNavigation.down: pageLoader

            anchors.top: parent.top
            anchors.topMargin: Units.dtPx(11)
            anchors.left: parent.left
            anchors.leftMargin: Units.dtPx(10)
            anchors.right: unity2dConfiguration.formFactor == "desktop" ? filterPane.left : indicators.left
            anchors.rightMargin: unity2dConfiguration.formFactor == "desktop" ? Units.dtPx(15) : Units.tvPx(80)

            height: Units.dtPx(42)
        }

        FilterPane {
            id: filterPane

            KeyNavigation.left: search_entry

            /* FilterPane is only to be displayed for lenses, not in the home page or Alt+F2 Run page */
            visible: unity2dConfiguration.formFactor == "desktop" && declarativeView.activeLens != "" && declarativeView.activeLens != "commands.lens"
            lens: visible && currentPage != undefined ? currentPage.model : undefined

            anchors.top: search_entry.anchors.top
            anchors.topMargin: search_entry.anchors.topMargin
            anchors.bottom: unity2dConfiguration.formFactor != "tv" ? lensBar.top : parent.bottom
            headerHeight: search_entry.height
            width: Units.dtPx(300)
            anchors.right: parent.right
            anchors.rightMargin: Units.dtPx(8)
        }

        Loader {
            id: pageLoader

            Accessible.name: "loader"
            /* FIXME: check on visible necessary; fixed in Qt Quick 1.1
                      ref: http://bugreports.qt.nokia.com/browse/QTBUG-15862
            */
            KeyNavigation.right: filterPane.visible && !filterPane.folded ? filterPane : pageLoader
            KeyNavigation.up: search_entry
            KeyNavigation.down: lensBar

            anchors.top: search_entry.bottom
            anchors.topMargin: if (unity2dConfiguration.formFactor == "desktop") Units.dtPx(9)
                               else if (unity2dConfiguration.formFactor == "tv") Units.tvPx(16)
            anchors.bottom: unity2dConfiguration.formFactor != "tv" ? lensBar.top : parent.bottom
            anchors.left: parent.left
            anchors.right: !filterPane.visible || filterPane.folded ? parent.right : filterPane.left
            anchors.rightMargin: !filterPane.visible || filterPane.folded ? 0 : 15
            onLoaded: item.focus = true

            /* Workaround loss of focus issue happening when the loaded item has
               active focus and is then destroyed. The active focus was completely
               lost instead of being relinquished to the Loader.

               Ref.: https://bugreports.qt.nokia.com/browse/QTBUG-22939
            */
            function setSource(newSource) {
                sourceAnimation.restart()
                var hadActiveFocus = activeFocus
                source = newSource
                if (hadActiveFocus) forceActiveFocus()
            }

            SequentialAnimation {
                id: sourceAnimation
                property string source
                property bool hadActiveFocus
                PropertyAction { target: pageLoader; property: "opacity"; value: 0 }
                NumberAnimation { duration: 2500 }
                NumberAnimation { target: pageLoader; property: "opacity"; to: 1; duration: 300; easing.type: Easing.OutQuad }
            }
        }

        DashIndicators {
            id: indicators
            height: Units.tvPx(120)
            anchors.verticalCenter: search_entry.verticalCenter
            anchors.right: parent.right
            anchors.rightMargin: Units.tvPx(27)
            KeyNavigation.left: search_entry
            KeyNavigation.down: pageLoader
            visible: unity2dConfiguration.formFactor == "tv"

            onActiveFocusChanged: {
                if (!activeFocus) leftIndicator.focus = true
            }
        }

        Previews {
            id: previewer
            anchors.fill: parent
            onExitRequested: hidePreview()
        }

        LensBar {
            id: lensBar

            KeyNavigation.up: pageLoader

            anchors.bottom: parent.bottom
            anchors.left: parent.left
            anchors.right: parent.right
            height: Units.dtPx(44)
            visible: declarativeView.expanded && unity2dConfiguration.formFactor != "tv"
        }

    }

    Rectangle {
        anchors.fill: sidebar
        color: "black"
        opacity: 0.5
    }
    MouseArea {
        anchors.fill: content
        enabled: !content.activeFocus
        onClicked: content.focus = true
    }

    Sidebar {
        id: sidebar
        source: "../dash/LensSidebar.qml"
        anchors.top: parent.top
        anchors.bottom: parent.bottom
        width: Units.tvPx(550) + borderWidth
        x: sidebarVisibility.shown ? parent.width - width : parent.width

        Behavior on x { NumberAnimation { duration: 125 } }

        Keys.onPressed: {
            if (event.key == Qt.Key_Escape || event.key == Qt.Key_Backspace) {
                sidebar.focus = false
                content.forceActiveFocus()
            }
        }

        // Prevent key navigation from the sidebar
        Keys.onLeftPressed: {}
        Keys.onRightPressed: {}

        Binding {
            target: sidebar.item
            property: "lens"
            value: currentPage != undefined ? currentPage.model : undefined
            when: sidebar.status == Loader.Ready
        }
    }

    VisibilityController {
        id: sidebarVisibility
        behavior: ImmediateHideBehavior {
            target: sidebar
        }
        onShownChanged: if (!shown) {
            sidebar.focus = false
            content.forceActiveFocus()
        }
    }

    AbstractButton {
        id: fullScreenButton

        Accessible.name: "Full Screen"

        anchors.bottom: parent.bottom
        anchors.right: parent.right
        anchors.rightMargin: 15
        anchors.bottomMargin: 15
        width: fullScreenButtonImage.sourceSize.width
        height: fullScreenButtonImage.sourceSize.height
        visible: declarativeView.dashMode != ShellDeclarativeView.FullScreenMode

        Image {
            id: fullScreenButtonImage
            source: "artwork/fullscreen_button.png"
            mirror: isRightToLeft()
        }

        onClicked: {
            declarativeView.dashMode = ShellDeclarativeView.FullScreenMode
        }
    }

    property int desktopCollapsedHeight: 115
    property int desktopExpandedHeight: 606
    property int desktopWidth: 989
    property int fullscreenWidth: screen.availableGeometry.width
    property int fullscreenHeight: screen.availableGeometry.height

    states: [
        State {
            name: "desktop"
            when: declarativeView.dashMode == ShellDeclarativeView.DesktopMode
            PropertyChanges {
                target: dash
                width: desktopWidth
                height: declarativeView.expanded ? desktopExpandedHeight : desktopCollapsedHeight
            }
        },
        State {
            name: "fullscreen"
            when: declarativeView.dashMode == ShellDeclarativeView.FullScreenMode
            PropertyChanges {
                target: dash
                width: fullscreenWidth
                height: fullscreenHeight
            }
        }
    ]
}