def _save_to_fs(self, data):
_data = copy.deepcopy(data, {})
del _data['categories']
if data.has_key('categories') and data['categories']:
_cat = [{'category': x} for x in data['categories']]
_data['categories'] = _cat
del _data['start']
if data.has_key('start') and data['start']:
_date = [{
'year': data['start'][0],
'month': data['start'][1],
'day': data['start'][2]
}]
_data['start'] = _date
del _data['end']
if data.has_key('end') and data['end']:
_date = [{
'year': data['end'][0],
'month': data['end'][1],
'day': data['end'][2]
}]
_data['end'] = _date
_dict = {'filter': _data}
database.ensurerecordtype(_dict, filterobjectfactory)
self.GetParent().GetParent().GetActiveDatabase().savemajordict(
'calendar_filter', _dict)
def _save_to_fs(self):
_data = {}
for _key, _entry in self._data.items():
_entry.validate_properties()
_data[_key] = self._expand_item(_entry)
database.ensurerecordtype(_data, importcalendarobjectfactory)
self._parent.GetActiveDatabase().savemajordict('imp_cal_preset', _data)
def getfromfs(self, dict):
"""Updates dict with info from disk
@Note: The dictionary passed in is modified, as well
as returned
@rtype: dict
@param dict: the dictionary to update
@return: the updated dictionary"""
self.thedir=self.mainwindow.calendarpath
if os.path.exists(os.path.join(self.thedir, "index.idx")):
dct={'result': {}}
common.readversionedindexfile(os.path.join(self.thedir, "index.idx"),
dct, self.versionupgrade,
self.CURRENTFILEVERSION)
converted=dct['result'].has_key('converted')
db_r={}
for k,e in dct['result'].get('calendar', {}).items():
if converted:
db_r[k]=CalendarDataObject(e)
else:
ce=CalendarEntry()
ce.set(e)
db_r[k]=CalendarDataObject(ce)
database.ensurerecordtype(db_r, calendarobjectfactory)
db_r=database.extractbitpimserials(db_r)
self.mainwindow.database.savemajordict('calendar', db_r)
os.rename(os.path.join(self.thedir, "index.idx"), os.path.join(self.thedir, "index-is-now-in-database.bak"))
cal_dict=self.mainwindow.database.getmajordictvalues('calendar',
calendarobjectfactory)
r={}
for k,e in cal_dict.items():
ce=CalendarEntry()
ce.set_db_dict(e)
r[ce.id]=ce
dict.update({ 'calendar': r })
return dict
def _save_to_db(self, todo_dict):
db_rr={}
for k, e in todo_dict.items():
db_rr[k]=TodoDataObject(e)
database.ensurerecordtype(db_rr, todoobjectfactory)
self._main_window.database.savemajordict('todo', db_rr)
self._publish_today_events()
self._publish_thisweek_events()
def _save_to_db(self, dict):
if self.read_only:
return
db_rr = {}
for k, e in dict.items():
db_rr[k] = CallHistoryDataobject(e)
database.ensurerecordtype(db_rr, callhistoryobjectfactory)
self._main_window.database.savemajordict(self._data_key, db_rr)
def _save_to_fs(self):
_data={}
for _key, _entry in self._data.items():
_entry.validate_properties()
_data[_key]=self._expand_item(_entry)
database.ensurerecordtype(_data, importcalendarobjectfactory)
self._parent.GetActiveDatabase().savemajordict('imp_cal_preset',
_data)
def _save_to_db(self, dict):
if self.read_only:
return
db_rr={}
for k,e in dict.items():
db_rr[k]=CallHistoryDataobject(e)
database.ensurerecordtype(db_rr, callhistoryobjectfactory)
self._main_window.database.savemajordict(self._data_key, db_rr)
def _save_to_db(self, todo_dict):
db_rr = {}
for k, e in todo_dict.items():
db_rr[k] = TodoDataObject(e)
database.ensurerecordtype(db_rr, todoobjectfactory)
self._main_window.database.savemajordict('todo', db_rr)
self._publish_today_events()
self._publish_thisweek_events()
def _save_to_db(self):
db_rr={}
self.settings.caltype=self.caltype.GetValue()
self.settings.sync_on_connect=self.sync_on_connect.GetValue()
self.settings.sync_frequency=self.sync_frequency.GetValue()
self.settings.id=self.profile
db_rr[self.settings.id]=AutoSyncSettingsobject(self.settings)
database.ensurerecordtype(db_rr, autosyncsettingsobjectfactory)
self.mw.tree.GetActivePhone().GetDatabase().savemajordict(_data_key, db_rr)
def save(self, db):
# save the current list to the database db
global dict_key
_rec=[]
for _,_list in self._data.items():
_rec+=[ { 'word': x } for x in _list ]
_dict={ dict_key: { 'words': _rec } }
database.ensurerecordtype(_dict, t9wordsdataobjectfactory)
db.savemajordict(dict_key, _dict)
def save(self, db):
# save the current list to the database db
global dict_key
_rec=[]
for _,_list in self._data.items():
_rec+=[ { 'word': x } for x in _list ]
_dict={ dict_key: { 'words': _rec } }
database.ensurerecordtype(_dict, t9wordsdataobjectfactory)
db.savemajordict(dict_key, _dict)
def _save_to_db(self):
db_rr = {}
self.settings.caltype = self.caltype.GetValue()
self.settings.sync_on_connect = self.sync_on_connect.GetValue()
self.settings.sync_frequency = self.sync_frequency.GetValue()
self.settings.id = self.profile
db_rr[self.settings.id] = AutoSyncSettingsobject(self.settings)
database.ensurerecordtype(db_rr, autosyncsettingsobjectfactory)
self.mw.tree.GetActivePhone().GetDatabase().savemajordict(
_data_key, db_rr)
def _save_to_db(self, dict):
db_rr={}
for k,e in dict.items():
db_rr[k]=MediaDataObject(e)
if db_rr[k].has_key('mediadata'):
md5_sum=md5.new(db_rr[k]['mediadata']).hexdigest()
fname=os.path.join(self.mainwindow.blob_path, md5_sum)
f=open(fname, "wb")
f.write(db_rr[k]['mediadata'])
f.close()
db_rr[k]['mediadata']=md5_sum
database.ensurerecordtype(db_rr, mediaobjectfactory)
self.mainwindow.database.savemajordict(self.database_key, db_rr)
def populatefs(self, dict):
"""Saves the dict to disk"""
if dict.get('calendar_version', None)==2:
cal_dict=self._convert2to3(dict.get('calendar', {}),
dict.get('ringtone-index', {}))
else:
cal_dict=dict.get('calendar', {})
db_rr={}
for k, e in cal_dict.items():
db_rr[k]=CalendarDataObject(e)
database.ensurerecordtype(db_rr, calendarobjectfactory)
db_rr=database.extractbitpimserials(db_rr)
self.mainwindow.database.savemajordict('calendar', db_rr)
return dict
def _save_to_db(self, sms_dict=None, canned_msg_dict=None):
if self.read_only:
return
if sms_dict is not None:
db_rr = {}
for k, e in sms_dict.items():
db_rr[k] = sms.SMSDataObject(e)
database.ensurerecordtype(db_rr, sms.smsobjectfactory)
self._main_window.database.savemajordict(self._data_key, db_rr)
if canned_msg_dict is not None:
db_rr = {}
db_rr[self._canned_data_key] = sms.CannedMsgDataObject(
canned_msg_dict)
database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory)
self._main_window.database.savemajordict(self._canned_data_key,
db_rr)
def _save_to_db(self, sms_dict=None, canned_msg_dict=None):
if self.read_only:
return
if sms_dict is not None:
db_rr={}
for k, e in sms_dict.items():
db_rr[k]=sms.SMSDataObject(e)
database.ensurerecordtype(db_rr, sms.smsobjectfactory)
self._main_window.database.savemajordict(self._data_key, db_rr)
if canned_msg_dict is not None:
db_rr={}
db_rr[self._canned_data_key]=sms.CannedMsgDataObject(
canned_msg_dict)
database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory)
self._main_window.database.savemajordict(self._canned_data_key,
db_rr)
def _save_to_fs(self, data):
_data=copy.deepcopy(data, {})
del _data['categories']
if data.has_key('categories') and data['categories']:
_cat=[{'category': x} for x in data['categories'] ]
_data['categories']=_cat
del _data['start']
if data.has_key('start') and data['start']:
_date=[{'year': data['start'][0], 'month': data['start'][1],
'day': data['start'][2] }]
_data['start']=_date
del _data['end']
if data.has_key('end') and data['end']:
_date=[{'year': data['end'][0], 'month': data['end'][1],
'day': data['end'][2] }]
_data['end']=_date
_dict={ 'filter': _data }
database.ensurerecordtype(_dict, filterobjectfactory)
self.GetParent().GetParent().database.savemajordict('calendar_filter',
_dict)
def _save_to_db(self, dict):
db_rr={}
for k,e in dict.items():
db_rr[k]=MediaDataObject(e)
if db_rr[k].has_key('mediadata'):
dir_name=os.path.join(self.mainwindow.blob_path, db_rr[k]['origin'])
try:
os.makedirs(dir_name)
except:
pass
if not os.path.isdir(dir_name):
raise Exception("Unable to create media directory "+dir_name)
relative_name=os.path.join(db_rr[k]['origin'], db_rr[k]['name'])
fname=os.path.join(self.mainwindow.blob_path, relative_name)
f=open(fname, "wb")
f.write(db_rr[k]['mediadata'])
f.close()
db_rr[k]['mediadata']=relative_name
database.ensurerecordtype(db_rr, mediaobjectfactory)
self.mainwindow.database.savemajordict(self.database_key, db_rr)
def _save_to_db(self, dict):
db_rr={ masterlist_key: MasterListDataObject(dict.get(masterlist_key, [])) }
database.ensurerecordtype(db_rr, masterlistobjectfactory)
self._mw.database.savemajordict(masterlist_key, db_rr)
_pl_list=dict.get(playlist_key, [])
db_rr={ playlists_list: PlaylistDataObject([x.name for x in _pl_list]) }
database.ensurerecordtype(db_rr, playlistobjectfactory)
self._mw.database.savemajordict(playlists_list, db_rr)
db_rr={ }
for e in _pl_list:
db_rr[e.name]=PlaylistEntryDataObject(e)
database.ensurerecordtype(db_rr, playlistentryobjectfactory)
self._mw.database.savemajordict(playlist_key, db_rr)
def _save_to_db(self, dict):
# first, save the master list of songs.
db_rr={ masterlist_key: MasterListDataObject(dict.get(masterlist_key, [])) }
database.ensurerecordtype(db_rr, masterlistobjectfactory)
self._mw.database.savemajordict(masterlist_key, db_rr)
# now, save the list of playlists
_pl_list=dict.get(playlist_key, [])
db_rr={ playlists_list: PlaylistDataObject([x.name for x in _pl_list]) }
database.ensurerecordtype(db_rr, playlistobjectfactory)
self._mw.database.savemajordict(playlists_list, db_rr)
# save the playlist entries
db_rr={ }
for e in _pl_list:
db_rr[e.name]=PlaylistEntryDataObject(e)
database.ensurerecordtype(db_rr, playlistentryobjectfactory)
self._mw.database.savemajordict(playlist_key, db_rr)
def _save_to_db(self):
db_rr={}
self.settings.caltype=self.caltype.GetValue()
self.settings.sync_on_connect=self.sync_on_connect.GetValue()
self.settings.sync_frequency=self.sync_frequency.GetValue()
self.settings.id=self.profile
db_rr[self.settings.id]=AutoSyncSettingsobject(self.settings)
database.ensurerecordtype(db_rr, autosyncsettingsobjectfactory)
self.mw.tree.GetActivePhone().GetDatabase().savemajordict(_data_key, db_rr)
def getfromfs(self):
self.settings=_getsettings(self.mw, self.profile)
self.caltype.SetValue(self.settings.caltype)
self.sync_on_connect.SetValue(int(self.settings.sync_on_connect))
self.sync_frequency.SetValue(int(self.settings.sync_frequency))
return
def IsConfigured(self):
return self.settings.caltype!='None'
def updatevariables(self):
self.mw.auto_save_dict=self.settings
def ShowModal(self):
self.getfromfs()
ec=wx.Dialog.ShowModal(self)
if ec==wx.ID_OK:
self._save_to_db()
self.updatevariables()
self.SetAutoSyncTimer()
return ec
def saveSize(self):
guiwidgets.save_size("AutoSyncSettingsDialog", self.GetRect())
def SetAutoSyncTimer(self):
self.auto_sync_timer.Stop()
oneShot = True
timeout=self.settings.sync_frequency*60000
if timeout:
self.auto_sync_timer.Start(timeout, oneShot)
self.Bind(wx.EVT_TIMER, self.OnTimer, self.auto_sync_timer)
def OnTimer(self, event):
self.mw.log("Auto Sync: Timed update")
SyncSchedule(self.mw).sync(self.mw, silent=1)
self.SetAutoSyncTimer()
def _save_to_db(self, dict):
if self.read_only:
return
db_rr={}
for k,e in dict.items():
db_rr[k]=CallHistoryDataobject(e)
database.ensurerecordtype(db_rr, callhistoryobjectfactory)
self._main_window.database.savemajordict(self._data_key, db_rr)
def populatefs(self, dict):
if self.read_only:
wx.MessageBox('You are viewing historical data which cannot be changed or saved',
'Cannot Save Call History Data',
style=wx.OK|wx.ICON_ERROR)
else:
self._save_to_db(dict.get(self._data_key, {}))
return dict
def getfromfs(self, result, timestamp=None):
dict=self._main_window.database.\
getmajordictvalues(self._data_key,
callhistoryobjectfactory,
at_time=timestamp)
r={}
for k,e in dict.items():
ce=CallHistoryEntry()
ce.set_db_dict(e)
r[ce.id]=ce
result.update({ self._data_key: r})
return result
def merge(self, dict):
if self.read_only:
wx.MessageBox('You are viewing historical data which cannot be changed or saved',
'Cannot Save Call History Data',
style=wx.OK|wx.ICON_ERROR)
return
d=dict.get(self._data_key, {})
l=[e for k,e in self._data.items()]
for k,e in d.items():
if e not in l:
self._data[e.id]=e
self._save_to_db(self._data)
self._populate()
def OnHistoricalData(self):
"""Display current or historical data"""
if self.read_only:
current_choice=guiwidgets.HistoricalDataDialog.Historical_Data
else:
current_choice=guiwidgets.HistoricalDataDialog.Current_Data
dlg=guiwidgets.HistoricalDataDialog(self,
current_choice=current_choice,
historical_date=self.historical_date,
historical_events=\
self._main_window.database.getchangescount(self._data_key))
if dlg.ShowModal()==wx.ID_OK:
self._main_window.OnBusyStart()
current_choice, self.historical_date=dlg.GetValue()
r={}
if current_choice==guiwidgets.HistoricalDataDialog.Current_Data:
self.read_only=False
msg_str='Current Data'
self.getfromfs(r)
else:
self.read_only=True
msg_str='Historical Data as of %s'%\
str(wx.DateTimeFromTimeT(self.historical_date))
self.getfromfs(r, self.historical_date)
self.populate(r, True)
self.historical_data_label.SetLabel(msg_str)
self._main_window.OnBusyEnd()
dlg.Destroy()
def get_selected_data(self):
res={}
for sel_idx in self._item_list.GetSelections():
k=self._item_list.GetPyData(sel_idx)
if k:
res[k]=self._data[k]
return res
def get_data(self):
return self._data
def _save_to_db(self, todo_dict):
db_rr={}
for k, e in todo_dict.items():
db_rr[k]=TodoDataObject(e)
database.ensurerecordtype(db_rr, todoobjectfactory)
self._main_window.database.savemajordict('todo', db_rr)
self._publish_today_events()
self._publish_thisweek_events()
def populatefs(self, dict):
self._save_to_db(dict.get('todo', {}))
return dict
def getfromfs(self, result):
todo_dict=self._main_window.database.\
getmajordictvalues('todo',todoobjectfactory)
r={}
for k,e in todo_dict.items():
ce=TodoEntry()
ce.set_db_dict(e)
r[ce.id]=ce
result.update({ 'todo': r })
return result
def _OnListBoxItem(self, evt):
self._populate_each(self._item_list.GetClientData(evt.GetInt()))
self.Refresh()
def _OnSave(self, evt):
self.ignoredirty=True
sel_idx=self._item_list.GetSelection()
k=self._item_list.GetClientData(sel_idx)
entry=self._data[k]
self._general_editor_w.Get(entry)
entry.note=self._memo_editor_w.Get().get('memo', None)
entry.categories=self._cat_editor_w.Get()
entry.check_completion()
self._general_editor_w.Set(entry)
self._item_list.SetString(sel_idx, entry.summary)
self._save_to_db(self._data)
self.ignoredirty=False
self.setdirty(False)
def _OnRevert(self, evt):
self.ignoredirty=True
sel_idx=self._item_list.GetSelection()
k=self._item_list.GetClientData(sel_idx)
self._populate_each(k)
self.ignoredirty=False
self.setdirty(False)
def _save_to_fs(self, data):
_dict = {URLDictKey: {'urls': data}}
database.ensurerecordtype(_dict, urlobjectfactory)
self._db.savemajordict(URLDictName, _dict)
def _save_to_db(self, dict):
db_rr={ masterlist_key: MasterListDataObject(dict.get(masterlist_key, [])) }
database.ensurerecordtype(db_rr, masterlistobjectfactory)
self._mw.database.savemajordict(masterlist_key, db_rr)
_pl_list=dict.get(playlist_key, [])
db_rr={ playlists_list: PlaylistDataObject([x.name for x in _pl_list]) }
database.ensurerecordtype(db_rr, playlistobjectfactory)
self._mw.database.savemajordict(playlists_list, db_rr)
db_rr={ }
for e in _pl_list:
db_rr[e.name]=PlaylistEntryDataObject(e)
database.ensurerecordtype(db_rr, playlistentryobjectfactory)
self._mw.database.savemajordict(playlist_key, db_rr)
def populatefs(self, dict):
self._save_to_db(dict)
return dict
def getfromfs(self, result):
_master_dict=self._mw.database.getmajordictvalues(masterlist_key,
masterlistobjectfactory)
_master_dict=_master_dict.get(masterlist_key, {})
result.update( { masterlist_key: \
[x['name'] for x in _master_dict.get(masterlist_key, [])] })
_pl_list_dict=self._mw.database.getmajordictvalues(playlists_list,
playlistobjectfactory)
_pl_list_dict=_pl_list_dict.get(playlists_list, {})
_pl_entries_dict=self._mw.database.getmajordictvalues(playlist_key,
playlistentryobjectfactory)
_pl_list=[]
for e in _pl_list_dict.get(playlist_key, []):
_pl_entry=_pl_entries_dict.get(e['name'], None)
if _pl_entry:
_entry=PlaylistEntry()
_entry.name=e['name']
_entry.type=_pl_entry['type']
_entry.songs=[x['name'] for x in _pl_entry['songs']]
_pl_list.append(_entry)
result.update({playlist_key: _pl_list })
return result
def OnMakeDirty(self, _=None):
"""A public function you can call that will set the dirty flag"""
if self.dirty or self.ignoredirty:
return
print 'OnMakeDirty'
self.setdirty(True)
def OnPlaylistSelected(self, evt):
self._populate_each(evt.GetLabel())
evt.Skip()
def OnDirty(self, _):
self.setdirty(True)
def _change_playlist_name(self, new_name):
for e in self._data:
if e.name==self._old_name:
e.name=new_name
def _add_playlist_name(self, new_name):
_entry=PlaylistEntry()
_entry.name=new_name
self._data.append(_entry)
def OnStartLabelChanged(self, evt):
self._old_name=evt.GetLabel()
def OnLabelChanged(self, evt):
_new_name=evt.GetLabel()
if _new_name:
self.setdirty(True)
if self._old_name:
self._change_playlist_name(_new_name)
else:
self._add_playlist_name(_new_name)
evt.Skip()
def OnAdd2Playlist(self, _):
_pl_idx=self._item_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED)
_master_idx=self._master_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED)
if _pl_idx==-1 or _master_idx==-1:
return
_entry_idx=self._name2idx(self._item_list_w.GetItemText(_pl_idx))
if _entry_idx is not None:
self.setdirty(True)
self._pl_list.SetStrings(self._pl_list.GetStrings()+\
[self._master_list_w.GetItemText(_master_idx)])
def _build_playlist(self):
_pl_list=[]
for _name in self._item_list.GetStrings():
if _name:
_idx=self._name2idx(_name)
if _idx is not None:
_pl_list.append(self._data[_idx])
return _pl_list
def OnSave(self, _):
_pl_idx=self._item_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED)
if _pl_idx!=-1:
_entry_idx=self._name2idx(self._item_list_w.GetItemText(_pl_idx))
if _entry_idx is not None:
self._data[_entry_idx].songs=self._pl_list.GetStrings()
self._save_to_db({ masterlist_key: self._master_list.GetStrings(),
playlist_key: self._build_playlist() })
self.setdirty(False)
def OnRevert(self, _):
_pl_idx=self._item_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED)
_res={}
self.getfromfs(_res)
self.populate(_res)
if _pl_idx!=-1:
self._item_list_w.SetItemState(_pl_idx, wx.LIST_STATE_SELECTED,
wx.LIST_MASK_STATE)
self.setdirty(False)
def getdata(self, dict):
dict[masterlist_key]=self._master_list.GetStrings()
dict[playlist_key]=self._build_playlist()
return dict
def _save_to_db(self, sms_dict=None, canned_msg_dict=None):
if self.read_only:
return
if sms_dict is not None:
db_rr={}
for k, e in sms_dict.items():
db_rr[k]=sms.SMSDataObject(e)
database.ensurerecordtype(db_rr, sms.smsobjectfactory)
self._main_window.database.savemajordict(self._data_key, db_rr)
if canned_msg_dict is not None:
db_rr={}
db_rr[self._canned_data_key]=sms.CannedMsgDataObject(
canned_msg_dict)
database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory)
self._main_window.database.savemajordict(self._canned_data_key,
db_rr)
def populatefs(self, dict):
if self.read_only:
wx.MessageBox('You are viewing historical data which cannot be changed or saved',
'Cannot Save SMS Data',
style=wx.OK|wx.ICON_ERROR)
return
canned_msg=sms.CannedMsgEntry()
canned_msg.set({ self._canned_data_key: dict.get(self._canned_data_key, [])})
self._save_to_db(sms_dict=dict.get(self._data_key, []),
canned_msg_dict=canned_msg)
return dict
def getfromfs(self, result, timestamp=None):
sms_dict=self._main_window.database.\
getmajordictvalues(self._data_key, sms.smsobjectfactory,
at_time=timestamp)
r={}
for k,e in sms_dict.items():
ce=sms.SMSEntry()
ce.set_db_dict(e)
r[ce.id]=ce
result.update({ self._data_key: r })
canned_msg_dict=self._main_window.database.\
getmajordictvalues(self._canned_data_key,
sms.cannedmsgobjectfactory)
for k,e in canned_msg_dict.items():
ce=sms.CannedMsgEntry()
ce.set_db_dict(e)
result.update(ce.get())
return result
def merge(self, dict):
if self.read_only:
wx.MessageBox('You are viewing historical data which cannot be changed or saved',
'Cannot Save SMS Data',
style=wx.OK|wx.ICON_ERROR)
return
existing_id=[e.msg_id for k,e in self._data.items()]
d=dict.get(self._data_key, {})
for k,e in d.items():
if e.msg_id not in existing_id:
self._data[e.id]=e
self._canned_data=sms.CannedMsgEntry()
self._canned_data.set({ self._canned_data_key: dict.get(self._canned_data_key, []) } )
self._populate()
self._save_to_db(sms_dict=self._data,
canned_msg_dict=self._canned_data)
def OnHistoricalData(self):
"""Display current or historical data"""
if self.read_only:
current_choice=guiwidgets.HistoricalDataDialog.Historical_Data
else:
current_choice=guiwidgets.HistoricalDataDialog.Current_Data
dlg=guiwidgets.HistoricalDataDialog(self,
current_choice=current_choice,
historical_date=self.historical_date,
historical_events=\
self._main_window.database.getchangescount(self._data_key))
if dlg.ShowModal()==wx.ID_OK:
self._main_window.OnBusyStart()
current_choice, self.historical_date=dlg.GetValue()
r={}
if current_choice==guiwidgets.HistoricalDataDialog.Current_Data:
self.read_only=False
msg_str='Current Data'
self.getfromfs(r)
else:
self.read_only=True
msg_str='Historical Data as of %s'%\
str(wx.DateTimeFromTimeT(self.historical_date))
self.getfromfs(r, self.historical_date)
self.populate(r, True)
self.historical_data_label.SetLabel(msg_str)
self._main_window.OnBusyEnd()
dlg.Destroy()
def _save_to_db(self, memo_dict):
db_rr = {}
for k, e in memo_dict.items():
db_rr[k] = MemoDataObject(e)
database.ensurerecordtype(db_rr, memoobjectfactory)
self._main_window.database.savemajordict('memo', db_rr)
def getfromfs(self, dict):
"""Updates dict with info from disk
@Note: The dictionary passed in is modified, as well
as returned
@rtype: dict
@param dict: the dictionary to update
@return: the updated dictionary"""
self.thedir=self.mainwindow.calendarpath
if os.path.exists(os.path.join(self.thedir, "index.idx")):
dct={'result': {}}
common.readversionedindexfile(os.path.join(self.thedir, "index.idx"),
dct, self.versionupgrade,
self.CURRENTFILEVERSION)
converted=dct['result'].has_key('converted')
db_r={}
for k,e in dct['result'].get('calendar', {}).items():
if converted:
db_r[k]=CalendarDataObject(e)
else:
ce=CalendarEntry()
ce.set(e)
db_r[k]=CalendarDataObject(ce)
database.ensurerecordtype(db_r, calendarobjectfactory)
db_r=database.extractbitpimserials(db_r)
self.mainwindow.database.savemajordict('calendar', db_r)
os.rename(os.path.join(self.thedir, "index.idx"), os.path.join(self.thedir, "index-is-now-in-database.bak"))
cal_dict=self.mainwindow.database.getmajordictvalues('calendar',
calendarobjectfactory)
r={}
for k,e in cal_dict.items():
ce=CalendarEntry()
ce.set_db_dict(e)
r[ce.id]=ce
dict.update({ 'calendar': r })
return dict
def versionupgrade(self, dict, version):
"""Upgrade old data format read from disk
@param dict: The dict that was read in
@param version: version number of the data on disk
"""
if version==0:
version=1
if version==1:
version=2
for k in dict['result']['calendar']:
entry=dict['result']['calendar'][k]
entry['daybitmap']=self.getdaybitmap(entry['start'], entry['repeat'])
del entry['?d']
if version==2:
version=3
dict['result']['calendar']=self.convert_dict(dict['result'].get('calendar', {}), 2, 3)
dict['result']['converted']=True
def convert_dict(self, dict, from_version, to_version, ringtone_index={}):
"""
Convert the calendatr dict from one version to another.
Currently only support conversion between version 2 and 3.
"""
if dict is None:
return None
if from_version==2 and to_version==3:
return self._convert2to3(dict, ringtone_index)
elif from_version==3 and to_version==2:
return self._convert3to2(dict, ringtone_index)
else:
raise 'Invalid conversion'
def _convert2to3(self, dict, ringtone_index):
"""
Convert calendar dict from version 2 to 3.
"""
r={}
for k,e in dict.items():
ce=CalendarEntry()
ce.start=e['start']
ce.end=e['end']
ce.description=e['description']
ce.alarm=e['alarm']
ce.ringtone=ringtone_index.get(e['ringtone'], {}).get('name', '')
repeat=e['repeat']
if repeat is None:
ce.repeat=None
else:
repeat_entry=RepeatEntry()
if repeat=='daily':
repeat_entry.repeat_type=repeat_entry.daily
repeat_entry.interval=1
elif repeat=='monfri':
repeat_entry.repeat_type=repeat_entry.daily
repeat_entry.interval=0
elif repeat=='weekly':
repeat_entry.repeat_type=repeat_entry.weekly
repeat_entry.interval=1
dow=datetime.date(*e['start'][:3]).isoweekday()%7
repeat_entry.dow=1<<dow
elif repeat=='monthly':
repeat_entry.repeat_type=repeat_entry.monthly
else:
repeat_entry.repeat_type=repeat_entry.yearly
s=[]
for n in e.get('exceptions',[]):
s.append(bptime.BPTime(n))
repeat_entry.suppressed=s
ce.repeat=repeat_entry
r[ce.id]=ce
return r
def _convert_daily_events(self, e, d):
""" Conver a daily event from v3 to v2 """
rp=e.repeat
if rp.interval==1:
d['repeat']='daily'
elif rp.interval==0:
d['repeat']='monfri'
else:
d['repeat']='daily'
t0=datetime.date(*e.start[:3])
t1=datetime.date(*e.end[:3])
delta_t=datetime.timedelta(1)
while t0<=t1:
if not e.is_active(t0.year, t0.month, t0.day):
d['exceptions'].append((t0.year, t0.month, t0.day))
t0+=delta_t
def _convert_weekly_events(self, e, d, idx):
"""
Convert a weekly event from v3 to v2
"""
rp=e.repeat
dow=rp.dow
t0=datetime.date(*e.start[:3])
t1=t3=datetime.date(*e.end[:3])
delta_t=datetime.timedelta(1)
delta_t7=datetime.timedelta(7)
if (t1-t0).days>6:
t1=t0+datetime.timedelta(6)
d['repeat']='weekly'
res={}
while t0<=t1:
dow_0=t0.isoweekday()%7
if (1<<dow_0)&dow:
dd=copy.deepcopy(d)
dd['start']=(t0.year, t0.month, t0.day, e.start[3], e.start[4])
dd['daybitmap']=self.getdaybitmap(dd['start'], dd['repeat'])
t2=t0
while t2<=t3:
if not e.is_active(t2.year, t2.month, t2.day):
dd['exceptions'].append((t2.year, t2.month, t2.day))
t2+=delta_t7
dd['pos']=idx
res[idx]=dd
idx+=1
t0+=delta_t
return idx, res
def _convert3to2(self, dict, ringtone_index):
"""Convert calendar dict from version 3 to 2."""
r={}
idx=0
for k,e in dict.items():
d={}
d['start']=e.start
d['end']=e.end
d['description']=e.description
d['alarm']=e.alarm
d['changeserial']=1
d['snoozedelay']=0
d['ringtone']=0
try:
d['ringtone']=[i for i,r in ringtone_index.items() \
if r.get('name', '')==e.ringtone][0]
except:
pass
rp=e.repeat
if rp is None:
d['repeat']=None
d['exceptions']=[]
d['daybitmap']=0
else:
s=[]
for n in rp.suppressed:
s.append(n.get()[:3])
d['exceptions']=s
if rp.repeat_type==rp.daily:
self._convert_daily_events(e, d)
elif rp.repeat_type==rp.weekly:
idx, rr=self._convert_weekly_events(e, d, idx)
r.update(rr)
continue
elif rp.repeat_type==rp.monthly:
d['repeat']='monthly'
elif rp.repeat_type==rp.yearly:
d['repeat']='yearly'
d['daybitmap']=self.getdaybitmap(d['start'], d['repeat'])
d['pos']=idx
r[idx]=d
idx+=1
if __debug__:
print 'Calendar._convert3to2: V2 dict:'
print r
return r
"""A class encapsulating the GUI and data of the calendar (all days). A seperate dialog is
used to edit the content of one particular day."""
class CalendarPrintDialog (wx.Dialog) :
_regular_template='cal_regular.xy'
_regular_style='cal_regular_style.xy'
_monthly_template='cal_monthly.xy'
_monthly_style='cal_monthly_style.xy'
def __init__(self, calwidget, mainwindow, config):
super(CalendarPrintDialog, self).__init__(mainwindow, -1, 'Print Calendar')
self._cal_widget=calwidget
self._xcp=self._html=self._dns=None
self._dt_index=self._dt_start=self._dt_end=None
self._date_changed=self._style_changed=False
self._tmp_file=common.gettempfilename("htm")
vbs=wx.BoxSizer(wx.VERTICAL)
hbs=wx.BoxSizer(wx.HORIZONTAL)
sbs=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Print Range'),
wx.VERTICAL)
gs=wx.FlexGridSizer(-1, 2, 5, 5)
gs.AddGrowableCol(1)
gs.Add(wx.StaticText(self, -1, 'Start:'), 0, wx.ALL, 0)
self._start_date=wx.DatePickerCtrl(self, style=wx.DP_DROPDOWN | wx.DP_SHOWCENTURY)
wx.EVT_DATE_CHANGED(self, self._start_date.GetId(),
self.OnDateChanged)
gs.Add(self._start_date, 0, wx.ALL, 0)
gs.Add(wx.StaticText(self, -1, 'End:'), 0, wx.ALL, 0)
self._end_date=wx.DatePickerCtrl(self, style=wx.DP_DROPDOWN | wx.DP_SHOWCENTURY)
wx.EVT_DATE_CHANGED(self, self._end_date.GetId(),
self.OnDateChanged)
gs.Add(self._end_date, 0, wx.ALL, 0)
sbs.Add(gs, 1, wx.EXPAND|wx.ALL, 5)
hbs.Add(sbs, 0, wx.ALL, 5)
self._print_style=wx.RadioBox(self, -1, 'Print Style',
choices=['List View', 'Month View'],
style=wx.RA_SPECIFY_ROWS)
wx.EVT_RADIOBOX(self, self._print_style.GetId(), self.OnStyleChanged)
hbs.Add(self._print_style, 0, wx.ALL, 5)
vbs.Add(hbs, 0, wx.ALL, 5)
vbs.Add(wx.StaticLine(self, -1), 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 5)
hbs=wx.BoxSizer(wx.HORIZONTAL)
for b in (('Print', -1, self.OnPrint),
('Page Setup', -1, self.OnPageSetup),
('Print Preview', -1, self.OnPrintPreview),
('Close', wx.ID_CANCEL, self.OnClose)):
btn=wx.Button(self, b[1], b[0])
hbs.Add(btn, 0, wx.ALIGN_CENTER|wx.ALL, 5)
if b[2] is not None:
wx.EVT_BUTTON(self, btn.GetId(), b[2])
vbs.Add(hbs, 0, wx.ALIGN_CENTRE|wx.EXPAND|wx.ALL, 5)
self.SetSizer(vbs)
self.SetAutoLayout(True)
vbs.Fit(self)
_one_day=wx.DateSpan(days=1)
_empty_day=['', []]
def _one_day_data(self):
r=[str(self._dt_index.GetDay())]
events=[]
if self._dt_start<=self._dt_index<=self._dt_end:
entries=self._cal_widget.getentrydata(self._dt_index.GetYear(),
self._dt_index.GetMonth()+1,
self._dt_index.GetDay())
else:
entries=[]
self._dt_index+=self._one_day
if len(entries):
entries.sort(CalendarEntry.cmp_by_time)
for e in entries:
print_data=e.print_data
events.append('%s: %s'%(print_data[0], print_data[3]))
r.append(events)
return r
def _one_week_data(self):
dow=self._dt_index.GetWeekDay()
if dow:
r=[self._empty_day]*dow
else:
r=[]
for d in range(dow, 7):
r.append(self._one_day_data())
if self._dt_index.GetDay()==1:
break
return r
def _one_month_data(self):
m=self._dt_index.GetMonth()
y=self._dt_index.GetYear()
r=['%s %d'%(self._dt_index.GetMonthName(m), y)]
while self._dt_index.GetMonth()==m:
r.append(self._one_week_data())
return r
def _get_monthly_data(self):
""" generate a dict suitable to print monthly events
"""
res=[]
self._dt_index=wx.DateTimeFromDMY(1, self._dt_start.GetMonth(),
self._dt_start.GetYear())
while self._dt_index<=self._dt_end:
res.append(self._one_month_data())
return res
def _get_list_data(self):
""" generate a dict suitable for printing"""
self._dt_index=wx.DateTimeFromDMY(self._dt_start.GetDay(),
self._dt_start.GetMonth(),
self._dt_start.GetYear())
current_month=None
res=a_month=month_events=[]
while self._dt_index<=self._dt_end:
y=self._dt_index.GetYear()
m=self._dt_index.GetMonth()
d=self._dt_index.GetDay()
entries=self._cal_widget.getentrydata(y, m+1, d)
self._dt_index+=self._one_day
if not len(entries):
continue
entries.sort(CalendarEntry.cmp_by_time)
if m!=current_month:
if len(month_events):
a_month.append(month_events)
res.append(a_month)
current_month=m
a_month=['%s %d'%(self._dt_index.GetMonthName(m), y)]
month_events=[]
for i,e in enumerate(entries):
if i:
date_str=day_str=''
else:
date_str=str(d)
day_str=self._dt_index.GetWeekDayName(
self._dt_index.GetWeekDay()-1, wx.DateTime.Name_Abbr)
month_events.append([date_str, day_str]+e.print_data)
if len(month_events):
a_month.append(month_events)
res.append(a_month)
return res
def _gen_print_data(self):
if not self._date_changed and \
not self._style_changed and \
self._html is not None:
return
self._dt_start=self._start_date.GetValue()
self._dt_end=self._end_date.GetValue()
if not self._dt_start.IsValid() or not self._dt_end.IsValid():
return
print_data=(
(self._regular_template, self._regular_style, self._get_list_data),
(self._monthly_template, self._monthly_style, self._get_monthly_data))
print_style=self._print_style.GetSelection()
print_dict=print_data[print_style][2]()
if self._xcp is None:
self._xcp=xyaptu.xcopier(None)
tmpl=file(guihelper.getresourcefile(print_data[print_style][0]),
'rt').read()
self._xcp.setupxcopy(tmpl)
elif self._style_changed:
tmpl=file(guihelper.getresourcefile(print_data[print_style][0]),
'rt').read()
self._xcp.setupxcopy(tmpl)
if self._dns is None:
self._dns={ 'common': __import__('common') }
self._dns['guihelper']=__import__('guihelper')
self._dns['events']=[]
self._dns['events']=print_dict
self._dns['date_range']='%s - %s'%\
(self._dt_start.FormatDate(),
self._dt_end.FormatDate())
html=self._xcp.xcopywithdns(self._dns.copy())
sd={'styles': {}, '__builtins__': __builtins__ }
try:
execfile(guihelper.getresourcefile(print_data[print_style][1]), sd, sd)
except UnicodeError:
common.unicode_execfile(guihelper.getresourcefile(print_data[print_style][1]), sd, sd)
try:
self._html=bphtml.applyhtmlstyles(html, sd['styles'])
except:
if __debug__:
file('debug.html', 'wt').write(html)
raise
self._date_changed=self._style_change=False
def OnDateChanged(self, _):
self._date_changed=True
def OnStyleChanged(self, _):
self._style_changed=True
def OnPrint(self, _):
self._gen_print_data()
wx.GetApp().htmlprinter.PrintText(self._html)
def OnPageSetup(self, _):
wx.GetApp().htmlprinter.PageSetup()
def OnPrintPreview(self, _):
self._gen_print_data()
wx.GetApp().htmlprinter.PreviewText(self._html)
def OnHelp(self, _):
pass
def OnClose(self, _):
try:
os.remove(self._tmp_file)
except:
pass
self.EndModal(wx.ID_CANCEL)
def _save_to_fs(self, data):
_dict={ URLDictKey: { 'urls': data } }
database.ensurerecordtype(_dict, urlobjectfactory)
self._db.savemajordict(URLDictName, _dict)
def _save_to_db(self, memo_dict):
db_rr={}
for k, e in memo_dict.items():
db_rr[k]=MemoDataObject(e)
database.ensurerecordtype(db_rr, memoobjectfactory)
self._main_window.database.savemajordict('memo', db_rr)
