← Back to branch summary

~elopio/gallery-app/revert_workaround-1302706-click_toolbar_button_failure

« back to all changes in this revision

Viewing changes to rc/qml/PickerScreen.qml

  • Committer: Leo Arias
  • Date: 2015-05-15 08:05:23 UTC
  • mfrom: (954.1.241 gallery-app)
  • Revision ID: leo.arias@canonical.com-20150515080523-i2of3vr8h7dioj59
Now the toolbar object is not needed at all.

Show diffs side-by-side

added added

removed removed

Lines of Context:
rc/qml/PickerScreen.qml
15
15
 */
16
16
 
17
17
import QtQuick 2.0
18
 
import Ubuntu.Components 0.1
 
18
import Ubuntu.Components 1.1
19
19
import Gallery 1.0
20
20
import "Components"
21
21
import "OrganicView"
22
22
import "Utility"
23
23
import "../js/Gallery.js" as Gallery
 
24
import "../js/GalleryUtility.js" as GalleryUtility
24
25
 
25
26
/*!
26
27
The main view for picking content
27
28
*/
28
29
MainView {
29
 
    id: pickerMainView
 
30
    id: overview
30
31
    objectName: "pickerMainView"
31
32
 
32
 
    /// Model of all media
33
 
    property MediaCollectionModel mediaLibrary: MediaCollectionModel {
34
 
        monitored: true
35
 
    }
36
 
    /// Holds the selection
37
 
    property SelectionState selection: SelectionState {
38
 
        inSelectionMode: true
39
 
        singleSelect: PICKER_HUB.singleContentPickMode
40
 
        model: mediaLibrary
 
33
    useDeprecatedToolbar: false
 
34
 
 
35
    function setHeaderVisibility(visible)
 
36
    {
 
37
        header.visible = visible;    
 
38
    }
 
39
 
 
40
    function toggleHeaderVisibility()
 
41
    {
 
42
        setHeaderVisibility(!header.visible);    
 
43
    }
 
44
 
 
45
    function pushPage(page) {
 
46
        pageStack.push(page);
 
47
    }
 
48
 
 
49
    function popPage() {
 
50
        pageStack.pop();
 
51
    }
 
52
 
 
53
    PageStack {
 
54
        id: pageStack
 
55
        anchors.fill: parent
 
56
    }
 
57
 
 
58
    Loader {
 
59
        id: mediaLibraryLoader
 
60
        sourceComponent: allLoaded ? mediaLibraryComponent : ""        
 
61
 
 
62
        Component {
 
63
            id: mediaLibraryComponent
 
64
            MediaCollectionModel {
 
65
                monitored: true
 
66
                mediaTypeFilter: APP.mediaTypeFilter
 
67
            }
 
68
        }
 
69
    }
 
70
 
 
71
    Loader {
 
72
        id: selectionLoader
 
73
        sourceComponent: allLoaded ? selectionComponent : ""
 
74
      
 
75
        Component {
 
76
            id: selectionComponent
 
77
            SelectionState {
 
78
                inSelectionMode: true
 
79
                singleSelect: PICKER_HUB.singleContentPickMode
 
80
                model: mediaLibraryLoader.item
 
81
            }
 
82
        }
41
83
    }
42
84
 
43
85
    anchors.fill: parent
44
 
    applicationName: "gallery-app"
 
86
    applicationName: "com.ubuntu.gallery"
45
87
    automaticOrientation: application.automaticOrientation
46
88
 
 
89
    Component.onCompleted: {
 
90
        pageStack.push(tabs);
 
91
    }
 
92
 
47
93
    Tabs {
48
94
        id: tabs
49
95
        anchors.fill: parent
51
97
        StateSaver.properties: "selectedTabIndex"
52
98
 
53
99
        Tab {
 
100
            id: eventsTab
54
101
            title: i18n.tr("Events")
55
102
            objectName: "eventsTab"
56
 
            page: OrganicView {
57
 
                id: eventSelectView
58
 
                objectName: "eventSelectView"
59
 
 
60
 
                tools: pickTools
61
 
                selection: pickerMainView.selection
62
 
                model: EventCollectionModel {
63
 
                }
64
 
 
65
 
                delegate: OrganicMediaList {
66
 
                    width: eventSelectView.width
67
 
                    event: model.event
68
 
                    selection: eventSelectView.selection
 
103
            page: Loader {
 
104
                id: eventSelectViewLoader
 
105
                objectName: 'eventSelectViewLoader'
 
106
                anchors.fill: parent
 
107
                sourceComponent: allLoaded ? eventSelectViewComponent : loadingScreenComponent
 
108
 
 
109
                Component {
 
110
                    id: eventSelectViewComponent
 
111
 
 
112
                    OrganicView {
 
113
                        id: eventSelectView
 
114
                        objectName: "eventSelectView"
 
115
 
 
116
                        head.actions: pickActions
 
117
 
 
118
                        selection: allLoaded ? selectionLoader.item : ""
 
119
                        model: EventCollectionModel {
 
120
                            mediaTypeFilter: APP.mediaTypeFilter
 
121
                        }
 
122
 
 
123
                        delegate: OrganicMediaList {
 
124
                            id: organicList
 
125
                            width: eventSelectView.width
 
126
                            event: model.event
 
127
                            selection: eventSelectView.selection
 
128
                            mediaTypeFilter: APP.mediaTypeFilter
 
129
                            onPressed: {
 
130
                                var rect = GalleryUtility.translateRect(thumbnailRect, organicList,
 
131
                                eventSelectView);
 
132
                                eventSelectView.mediaSourcePressed(mediaSource, rect);
 
133
                            }
 
134
                        }
 
135
 
 
136
                        onMediaSourcePressed: {
 
137
                            photoViewerLoader.load();
 
138
                            var rect = GalleryUtility.translateRect(thumbnailRect,
 
139
                                                                    eventSelectView,
 
140
                                                                    photoViewerLoader);
 
141
                            photoViewerLoader.item.title = i18n.tr("Select");
 
142
                            photoViewerLoader.item.selection = selection;
 
143
                            photoViewerLoader.item.animateOpen(mediaSource, rect);
 
144
                        }
 
145
                    }
69
146
                }
70
147
            }
71
148
        }
72
149
 
73
150
        Tab {
 
151
            id: photosTab
74
152
            title: i18n.tr("Photos")
75
153
            objectName: "photosTab"
76
 
            page: Page {
77
 
                id: photosOverview
78
 
 
79
 
                tools: pickTools
80
 
 
81
 
                Image {
82
 
                    anchors.fill: parent
83
 
                    source: "../img/background-paper.png"
84
 
                    fillMode: Image.Tile
85
 
                }
86
 
 
87
 
                MediaGrid {
88
 
                    anchors.fill: parent
89
 
                    model: mediaLibrary
90
 
                    selection: pickerMainView.selection
91
 
                }
92
 
            }
93
 
        }
94
 
    }
95
 
 
96
 
    property ToolbarItems pickTools: ToolbarItems {
97
 
        Button {
98
 
            anchors.verticalCenter: parent.verticalCenter
 
154
            page: Loader {
 
155
                id: photosOverviewLoader
 
156
                objectName: 'photosOverviewLoader'
 
157
                anchors.fill: parent
 
158
                sourceComponent: allLoaded ? photosOverviewComponent : loadingScreenComponent
 
159
 
 
160
                Component {
 
161
                    id: photosOverviewComponent
 
162
            
 
163
                    Page {
 
164
                        id: photosOverview
 
165
                        objectName: "photosPage"
 
166
 
 
167
                        head.actions: pickActions
 
168
 
 
169
                        signal mediaSourcePressed(var mediaSource, var thumbnailRect)
 
170
 
 
171
                        Connections {
 
172
                            target: photoViewerLoader.item
 
173
                            onSelected: photosGrid.positionViewAtIndex(index, GridView.Contain);
 
174
                        }
 
175
 
 
176
                        Image {
 
177
                            anchors.fill: parent
 
178
                            source: "../img/background-paper.png"
 
179
                            fillMode: Image.Tile
 
180
                        }
 
181
 
 
182
                        MediaGrid {
 
183
                            id: photosGrid
 
184
                            anchors.fill: parent
 
185
                            model: allLoaded ? mediaLibraryLoader.item : ""
 
186
                            selection: allLoaded ? selectionLoader.item : ""
 
187
                        }
 
188
 
 
189
                        onMediaSourcePressed: {
 
190
                            photoViewerLoader.load();
 
191
                            var rect = GalleryUtility.translateRect(thumbnailRect,
 
192
                                                                    photosOverview,
 
193
                                                                    photoViewerLoader);
 
194
                            photoViewerLoader.item.title = i18n.tr("Select");
 
195
                            photoViewerLoader.item.selection = photosGrid.selection;
 
196
                            photoViewerLoader.item.animateOpen(mediaSource, rect);
 
197
                        }
 
198
                    }
 
199
                }
 
200
            }
 
201
        }
 
202
    }
 
203
 
 
204
    Component {
 
205
        id: loadingScreenComponent
 
206
        LoadingScreen {
 
207
            id: loadingScreen
 
208
            anchors.fill: parent
 
209
        }
 
210
    }
 
211
 
 
212
    Loader {
 
213
        id: photoViewerLoader
 
214
 
 
215
        anchors.fill: parent
 
216
        z: 100
 
217
 
 
218
        function load() {
 
219
            setSource(Qt.resolvedUrl("MediaViewer/PopupPhotoViewer.qml"), {model: mediaLibraryLoader.item});
 
220
        }
 
221
 
 
222
        Connections {
 
223
            target: photoViewerLoader.item
 
224
            onCloseRequested: {
 
225
                if (!APP.desktopMode)
 
226
                    setFullScreen(false);
 
227
                popPage();
 
228
                photoViewerLoader.item.fadeClosed();
 
229
            }
 
230
        }
 
231
    }
 
232
 
 
233
    property list<Action> pickActions: [
 
234
        Action {
 
235
            text: i18n.tr("Cancel")
 
236
            objectName: "cancelButton"
 
237
            iconName: "close"
 
238
            onTriggered: APP.contentPickingCanceled()
 
239
        },
 
240
        Action {
99
241
            text: i18n.tr("Pick")
100
242
            objectName: "pickButton"
101
 
            color: Gallery.HIGHLIGHT_BUTTON_COLOR
102
 
            width: units.gu(16)
103
 
            enabled: pickerMainView.selection.selectedCount > 0
104
 
            onClicked: {
 
243
            enabled: allLoaded ? selectionLoader.item.selectedCount > 0 : false
 
244
            iconName: "ok"
 
245
            onTriggered: {
105
246
                if (!enabled)
106
247
                    return;
107
 
 
108
 
                APP.returnPickedContent(mediaLibrary.selectedMedias);
109
 
            }
110
 
        }
111
 
 
112
 
        back: Button {
113
 
            anchors.verticalCenter: parent.verticalCenter
114
 
            text: i18n.tr("Cancel")
115
 
            objectName: "cancelButton"
116
 
            width: units.gu(10)
117
 
            onClicked: {
118
 
                APP.contentPickingCanceled()
119
 
            }
120
 
        }
121
 
        opened: true
122
 
        locked: true
123
 
    }
 
248
                if (allLoaded)
 
249
                    APP.returnPickedContent(mediaLibraryLoader.item.selectedMedias);
 
250
            }
 
251
        }
 
252
    ]
124
253
}