← Back to branch summary

~pkunal-parmar/ubuntu-calendar-app/ICalImport

« back to all changes in this revision

Viewing changes to TimeLineBase.qml

  • Committer: Kunal Parmar
  • Date: 2013-09-28 09:37:52 UTC
  • mto: This revision was merged to the branch mainline in revision 153.
  • Revision ID: pkunal.parmar@gmail.com-20130928093752-6hhmsea2xmtns5uk
Background added to day labels

Show diffs side-by-side

added added

removed removed

Lines of Context:
TimeLineBase.qml
1
 
/*
2
 
 * Copyright (C) 2013-2014 Canonical Ltd
3
 
 *
4
 
 * This file is part of Ubuntu Calendar App
5
 
 *
6
 
 * Ubuntu Calendar App is free software: you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License version 3 as
8
 
 * published by the Free Software Foundation.
9
 
 *
10
 
 * Ubuntu Calendar App is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
 
 */
18
 
import QtQuick 2.3
19
 
import Ubuntu.Components 1.1
20
 
import QtOrganizer 5.0
21
 
 
 
1
import QtQuick 2.0
 
2
import Ubuntu.Components 0.1
22
3
import "dateExt.js" as DateExt
23
4
 
24
5
Item {
26
7
 
27
8
    property var delegate;
28
9
    property var day;
29
 
    property int hourHeight: units.gu(8)
30
 
    property var model;
31
 
 
32
 
    Component.onCompleted: {
33
 
        bubbleOverLay.createEvents();
34
 
    }
35
 
 
36
 
    MouseArea {
37
 
        anchors.fill: parent
38
 
        objectName: "mouseArea"
39
 
        onPressAndHold: {
40
 
            var selectedDate = new Date(day);
41
 
            var hour = parseInt(mouseY / hourHeight);
42
 
            selectedDate.setHours(hour)
43
 
            //pageStack.push(Qt.resolvedUrl("NewEvent.qml"), {"date":selectedDate, "model":eventModel});
44
 
            createOrganizerEvent(selectedDate);
45
 
        }
46
 
 
47
 
        onPressed: {
48
 
            intern.now = new Date();
49
 
            if( intern.now.isSameDay( bubbleOverLay.day ) ) {
50
 
                bubbleOverLay.showSeparator();
51
 
            }
52
 
        }
53
 
    }
54
 
 
55
 
    function getTimeFromYPos(y, day) {
56
 
        var date = new Date(day);
57
 
        var time = y / hourHeight;
58
 
        var minutes = time % 1 ;
59
 
        var hour = time - minutes;
60
 
        minutes = parseInt(60 * minutes);
61
 
        minutes = Math.floor(minutes/15) * 15;
62
 
        date.setHours(hour);
63
 
        date.setMinutes(minutes);
64
 
        return date;
65
 
    }
66
 
 
67
 
    function createOrganizerEvent( startDate ) {
68
 
        var event = Qt.createQmlObject("import QtOrganizer 5.0; Event {}", Qt.application,"TimeLineBase.qml");
69
 
        event.collectionId = (model.defaultCollection().collectionId);
70
 
        var endDate = new Date( startDate.getTime() + 3600000 );
71
 
        event.startDateTime = startDate;
72
 
        event.endDateTime = endDate;
73
 
        event.displayLabel = i18n.tr("Untitled");
74
 
        model.saveItem(event);
75
 
    }
76
 
 
77
 
    TimeSeparator {
 
10
    property int hourHeight: units.gu(10)
 
11
 
 
12
    EventListModel {
 
13
        id: model
 
14
        termStart: bubbleOverLay.day.midnight()
 
15
        termLength: Date.msPerDay
 
16
 
 
17
        onReloaded: {
 
18
            bubbleOverLay.createEvents();
 
19
        }
 
20
    }
 
21
 
 
22
    TimeSeparator{
78
23
        id: separator
79
24
        objectName: "separator"
80
25
        width:  bubbleOverLay.width
81
 
        visible: false
82
26
        z:1
83
27
    }
84
28
 
85
29
    QtObject {
86
30
        id: intern
87
31
        property var now : new Date();
88
 
        property var eventMap;
89
 
        property var unUsedEvents: new Object();
90
32
    }
91
33
 
92
34
    function showEventDetails(event) {
93
 
        pageStack.push(Qt.resolvedUrl("EventDetails.qml"), {"event":event,"model":model});
94
 
    }
95
 
 
96
 
    WorkerScript {
97
 
        id: eventLayoutHelper
98
 
        source: "EventLayoutHelper.js"
99
 
 
100
 
        onMessage: {
101
 
            layoutEvents(messageObject.schedules,messageObject.maxDepth);
102
 
        }
103
 
    }
104
 
 
105
 
    function layoutEvents(array, depth) {
106
 
        for(var i=0; i < array.length ; ++i) {
107
 
            var schedule = array[i];
108
 
            var event = intern.eventMap[schedule.id];
109
 
            bubbleOverLay.createEvent(event , schedule.depth, depth +1);
110
 
        }
 
35
        pageStack.push(Qt.resolvedUrl("EventDetails.qml"),{"event":event});
111
36
    }
112
37
 
113
38
    function createEvents() {
114
 
        if(!bubbleOverLay || bubbleOverLay == undefined || model === undefined || model === null) {
115
 
            return;
116
 
        }
117
 
 
118
 
        destroyAllChildren();
119
 
 
120
 
        var eventMap = {};
121
 
        var allSchs = [];
122
 
 
123
 
        var startDate = new Date(day).midnight();
124
 
        var endDate = new Date(day).endOfDay();
125
 
        var items = model.getItems(startDate,endDate);
126
 
        for(var i = 0; i < items.length; ++i) {
127
 
            var event = items[i];
128
 
 
129
 
            if(event.allDay) {
130
 
                continue;
 
39
        bubbleOverLay.destroyAllChildren();
 
40
 
 
41
        for(var i = 0 ; i < model.count ; ++i) {
 
42
            var event = model.get(i);
 
43
            if( event ) {
 
44
                bubbleOverLay.createEvent(event,event.startTime.getHours());
131
45
            }
132
 
 
133
 
            var schedule = {"startDateTime": event.startDateTime, "endDateTime": event.endDateTime,"id":event.itemId };
134
 
            allSchs.push(schedule);
135
 
            eventMap[event.itemId] = event;
136
46
        }
137
47
 
138
 
        intern.eventMap = eventMap;
139
 
        eventLayoutHelper.sendMessage(allSchs);
140
 
 
141
48
        if( intern.now.isSameDay( bubbleOverLay.day ) ) {
142
 
            bubbleOverLay.showSeparator();
 
49
            bubbleOverLay.showSeparator(intern.now.getHours());
143
50
        }
144
51
    }
145
52
 
146
53
    function destroyAllChildren() {
147
54
        for( var i = children.length - 1; i >= 0; --i ) {
148
 
            if( children[i].objectName === "mouseArea" ||
149
 
                    children[i].objectName === "weekdevider") {
150
 
                continue;
151
 
            }
152
 
            children[i].visible = false;
153
 
            if( children[i].objectName !== "separator") {
154
 
                children[i].clicked.disconnect( bubbleOverLay.showEventDetails );
155
 
                var key = children[i].objectName;
156
 
                if (intern.unUsedEvents[key] === "undefined") {
157
 
                    intern.unUsedEvents[key] = children[i];
158
 
                }
159
 
            }
160
 
        }
161
 
    }
162
 
 
163
 
    function isHashEmpty(hash) {
164
 
        for (var prop in hash) {
165
 
            if (prop)
166
 
                return false;
167
 
        }
168
 
        return true;
169
 
    }
170
 
 
171
 
    function getAKeyFromHash(hash) {
172
 
        for (var prop in hash) {
173
 
            return prop;
174
 
        }
175
 
        return "undefined";
176
 
    }
177
 
 
178
 
    function getUnusedEventBubble() {
179
 
        /* Recycle an item from unUsedEvents, and remove from hash */
180
 
        var key = getAKeyFromHash(intern.unUsedEvents);
181
 
        var unUsedBubble = intern.unUsedEvents[key];
182
 
        delete intern.unUsedEvents[key];
183
 
 
184
 
        return unUsedBubble;
185
 
    }
186
 
 
187
 
    function createEvent( event, depth, sizeOfRow ) {
188
 
        var eventBubble;
189
 
        if( isHashEmpty(intern.unUsedEvents) ) {
190
 
            var incubator = delegate.incubateObject(bubbleOverLay);
191
 
            if (incubator.status !== Component.Ready) {
192
 
                incubator.onStatusChanged = function(status) {
193
 
                    if (status === Component.Ready) {
194
 
                        incubator.object.objectName = children.length;
195
 
                        assignBubbleProperties(incubator.object, event, depth, sizeOfRow);
196
 
                    }
197
 
                }
 
55
            if( children[i].objectName === "separator") {
 
56
                children[i].visible = false;
198
57
            } else {
199
 
                incubator.object.objectName = children.length;
200
 
                assignBubbleProperties(incubator.object, event, depth, sizeOfRow);
 
58
                children[i].destroy();
201
59
            }
202
 
        } else {
203
 
            eventBubble = getUnusedEventBubble();
204
 
            assignBubbleProperties(eventBubble, event, depth, sizeOfRow);
205
60
        }
206
61
    }
207
62
 
208
 
    function assignBubbleProperties(eventBubble, event, depth, sizeOfRow) {
209
 
        var hour = event.startDateTime.getHours();
210
 
        var yPos = (( event.startDateTime.getMinutes() * hourHeight) / 60) + hour * hourHeight
 
63
    function createEvent( event ,hour) {
 
64
        var eventBubble = delegate.createObject(bubbleOverLay);
 
65
 
 
66
        eventBubble.clicked.connect( bubbleOverLay.showEventDetails );
 
67
 
 
68
        eventBubble.event = event
 
69
 
 
70
        var yPos = (( event.startTime.getMinutes() * hourHeight) / 60) + hour * hourHeight
211
71
        eventBubble.y = yPos;
212
72
 
213
 
        var durationMin = (event.endDateTime.getHours() - event.startDateTime.getHours()) * 60;
214
 
        durationMin += (event.endDateTime.getMinutes() - event.startDateTime.getMinutes());
 
73
        var durationMin = (event.endTime.getHours() - event.startTime.getHours()) * 60;
 
74
        durationMin += (event.endTime.getMinutes() - event.startTime.getMinutes());
215
75
        var height = (durationMin * hourHeight )/ 60;
216
 
        eventBubble.height = (height > eventBubble.minimumHeight) ? height:eventBubble.minimumHeight ;
217
 
 
218
 
        eventBubble.model = bubbleOverLay.model
219
 
        eventBubble.depthInRow = depth;
220
 
        eventBubble.sizeOfRow = sizeOfRow;
221
 
        eventBubble.event = event
222
 
        eventBubble.visible = true;
223
 
        eventBubble.clicked.connect( bubbleOverLay.showEventDetails );
 
76
        eventBubble.height = height;
224
77
    }
225
78
 
226
 
    function showSeparator() {
227
 
        var y = ((intern.now.getMinutes() * hourHeight) / 60) + intern.now.getHours() * hourHeight;
 
79
    function showSeparator(hour) {
 
80
        var y = ((intern.now.getMinutes() * hourHeight) / 60) + hour * hourHeight;
228
81
        separator.y = y;
229
82
        separator.visible = true;
230
83
    }