← Back to branch summary

~matias-wilkman/calendar-indicator/fix-1394124

« back to all changes in this revision

Viewing changes to src/calendarwindow.py

  • Committer: Lorenzo Carbonell
  • Date: 2012-11-26 21:13:19 UTC
  • Revision ID: lorenzo.carbonell.cerezo@gmail.com-20121126211319-rwf56ujpxgjmyvxz
Add, edit and delete events

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/calendarwindow.py
24
24
#
25
25
#
26
26
 
27
 
from gi.repository import Gtk, Gdk
 
27
from gi.repository import Gtk, Gdk, GObject
28
28
import os
29
29
import shutil
30
30
import locale
33
33
from configurator import Configuration
34
34
from googlecalendarapi import GoogleCalendar
35
35
from logindialog import LoginDialog
 
36
from eventwindow import EventWindow
 
37
 
36
38
import comun
37
39
 
38
40
locale.setlocale(locale.LC_ALL, '')
47
49
        return adatetime.weekday()
48
50
 
49
51
class DayWidget(Gtk.VBox):
50
 
        def __init__(self,adate=None):
 
52
        __gsignals__ = {
 
53
                'edited' : (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE,())
 
54
        }
 
55
        
 
56
        def __init__(self,googlecalendar=None,adate=None, callback = None):             
51
57
                Gtk.VBox.__init__(self)
52
58
                self.set_size_request(150, 100)
53
59
                scrolledwindow = Gtk.ScrolledWindow()
56
62
                self.pack_start(scrolledwindow,True,True,0)
57
63
                self.store = Gtk.ListStore(str, object,str)
58
64
                self.treeview = Gtk.TreeView(self.store)
 
65
                #self.treeview.connect('cursor-changed',self.on_cursor_changed)
 
66
                self.treeview.connect('button-release-event',self.on_cursor_changed)
59
67
                self.column = Gtk.TreeViewColumn('',  Gtk.CellRendererText(), text=0, background=2)
60
68
                self.treeview.append_column(self.column)
61
69
                scrolledwindow.add(self.treeview)
62
70
                if adate is not None:
63
 
                        self.set_date(adate)            
64
 
 
 
71
                        self.set_date(adate)
 
72
                self.googlecalendar = googlecalendar
 
73
                self.calendars = googlecalendar.calendars.values()
 
74
                self.callback = callback
 
75
                
 
76
        def on_cursor_changed(self,widget,key):
 
77
                if self.calendars is not None:
 
78
                        selection = widget.get_selection()
 
79
                        if selection is not None:
 
80
                                amodel,aiter = selection.get_selected()
 
81
                                aevent = amodel.get_value(aiter,1)
 
82
                                ew = EventWindow(self.calendars,aevent)
 
83
                                if ew.run() == Gtk.ResponseType.ACCEPT:
 
84
                                        if ew.get_operation() == 'DELETE':
 
85
                                                ew.destroy()
 
86
                                                md = Gtk.MessageDialog( parent = None,
 
87
                                                                                                flags = Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
 
88
                                                                                                type = Gtk.MessageType.ERROR,
 
89
                                                                                                buttons = Gtk.ButtonsType.OK_CANCEL,
 
90
                                                                                                message_format = _('Are you sure you want to revove this event?'))
 
91
                                                if md.run() == Gtk.ResponseType.OK:
 
92
                                                        md.destroy()                                    
 
93
                                                        if self.googlecalendar.remove_event(aevent['calendar_id'],aevent['id']):
 
94
                                                                self.googlecalendar.calendars[aevent['calendar_id']]['events'].pop(aevent['id'],True)
 
95
                                                                self.emit('edited')
 
96
                                                                self.callback()
 
97
                                                md.destroy()
 
98
                                        elif ew.get_operation() == 'EDIT':
 
99
                                                event_id = aevent['id']
 
100
                                                calendar_id = ew.get_calendar_id()
 
101
                                                summary = ew.get_summary()
 
102
                                                start_date = ew.get_start_date()
 
103
                                                end_date = ew.get_end_date()
 
104
                                                description = ew.get_description()
 
105
                                                ew.destroy()
 
106
                                                md = Gtk.MessageDialog( parent = None,
 
107
                                                                                                flags = Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
 
108
                                                                                                type = Gtk.MessageType.ERROR,
 
109
                                                                                                buttons = Gtk.ButtonsType.OK_CANCEL,
 
110
                                                                                                message_format = _('Are you sure you want to edit this event?'))
 
111
                                                if md.run() == Gtk.ResponseType.OK:
 
112
                                                        md.destroy()                                    
 
113
                                                        edit_event = self.googlecalendar.edit_event(calendar_id, event_id, summary, start_date, end_date, description)
 
114
                                                        if edit_event is not None:
 
115
                                                                self.googlecalendar.calendars[calendar_id]['events'][edit_event['id']] = edit_event
 
116
                                                                self.emit('edited')
 
117
                                                                self.callback()
 
118
                                                md.destroy()
 
119
                                ew.destroy()
 
120
                                selection.unselect_all()
65
121
        def set_date(self,adate):
66
122
                self.adate = adate
67
123
                self.column.set_title(str(adate.day))
83
139
                                color = configuration.get(event['calendar_id'])
84
140
                        else:
85
141
                                color = '#AFDEDF'
86
 
                        self.store.append([label,event,color])
 
142
                        if event is not None:
 
143
                                self.store.append([label,event,color])
87
144
        def set_background_color(self,color):
88
145
                self.treeview.modify_bg(Gtk.StateType.NORMAL, color)
89
146
        
97
154
                self.set_resizable(False)
98
155
                self.set_icon_from_file(comun.ICON)
99
156
                self.connect('destroy', self.close_application)
 
157
                self.edited = False
100
158
                #
101
159
                vbox0 = Gtk.VBox(spacing = 5)
102
160
                vbox0.set_border_width(5)
160
218
                        table1.attach(Gtk.Label(DAY_OF_WEEK[column-1]),column,column+1,0,1,xoptions = Gtk.AttachOptions.SHRINK, yoptions = Gtk.AttachOptions.SHRINK)
161
219
                for row in range(1,7):
162
220
                        for column in range(1,8):
163
 
                                self.days[contador] = DayWidget()
 
221
                                self.days[contador] = DayWidget(self.googlecalendar,callback=self.update)
 
222
                                self.days[contador].connect('edited',self.on_edited)
164
223
                                table1.attach(self.days[contador],column,column+1,row,row+1,xoptions = Gtk.AttachOptions.EXPAND, yoptions = Gtk.AttachOptions.EXPAND)
165
224
                                contador += 1
166
225
                #
173
232
                #
174
233
                self.show_all()
175
234
 
 
235
        def on_edited(self,widget):
 
236
                self.edited = True
 
237
 
 
238
        def get_edited(self):
 
239
                return self.edited
 
240
                
176
241
        def close_application(self,widget):
177
242
                self.ok = False
178
 
        
 
243
 
179
244
        def set_date(self):
180
245
                self.monthyear.set_text(self.adate.strftime('%B - %Y'))
181
246
                fdom = first_day_of_month(self.adate)
207
272
                                else:
208
273
                                        self.days[contador].clear()
209
274
                        
 
275
        def update(self):
 
276
                if self.googlecalendar is not None:
 
277
                        events = self.googlecalendar.getAllEventsOnMonth(self.adate)
 
278
                        for contador in range(0,42):
 
279
                                if self.days[contador].get_date().date() in events.keys():
 
280
                                        eventsday = events[self.days[contador].get_date().date()]
 
281
                                        if len(eventsday)>0:
 
282
                                                self.days[contador].set_events(eventsday)
 
283
                                        else:
 
284
                                                self.days[contador].clear()
 
285
                                else:
 
286
                                        self.days[contador].clear()
210
287
                
211
288
        def on_button0_clicked(self,widget):
212
289
                year = self.adate.year - 1