PyXR

c:\projects\bitpim\src \ sms_tab.py



0001 ### BITPIM
0002 ###
0003 ### Copyright (C) 2005 Joe Pham <djpham@netzero.net>
0004 ###
0005 ### This program is free software; you can redistribute it and/or modify
0006 ### it under the terms of the BitPim license as detailed in the LICENSE file.
0007 ###
0008 ### $Id: sms_tab.py 4474 2007-11-29 22:38:01Z djpham $
0009 
0010 """
0011 Code to handle the SMS Tab of the BitPim main display.
0012 The read flag is not required for outbox and saved message, delivery
0013 status is not needed for saved and inbox message, from is not required for
0014 save and outbox, to is not required for inbox etc.
0015 
0016 """
0017 # standard modules
0018 from __future__ import with_statement
0019 
0020 import copy
0021 
0022 # wx modules
0023 import wx
0024 import wx.gizmos as gizmos
0025 import wx.lib.scrolledpanel as scrolled
0026 
0027 # BitPim modules
0028 import common
0029 import database
0030 import guiwidgets
0031 import helpids
0032 import phonebookentryeditor as pb_editor
0033 import phonenumber
0034 import pubsub
0035 import sms
0036 import today
0037 import guihelper
0038 import guiwidgets
0039 import widgets
0040 import xyaptu
0041 
0042 #-------------------------------------------------------------------------------
0043 class StaticText(wx.StaticText):
0044     def __init__(self, parent, _=None):
0045         super(StaticText, self).__init__(parent, -1)
0046     def SetValue(self, v):
0047         if v.find('subject') and (v.find('\n')>-1):
0048             v=v.split('\n')[0]
0049         if len(v)==10 and v.isdigit():
0050                 v='(%03d)-%03d-%04d'%(int(v[:3]),int(v[3:6]),int(v[6:10]))
0051         elif len(v)==11 and v.isdigit() and v[0]=='1':
0052                 v='1-(%03d)-%03d-%04d'%(int(v[1:4]),int(v[4:7]),int(v[7:11]))
0053         self.SetLabel(v)
0054 
0055 #-------------------------------------------------------------------------------
0056 class TimeStamp(wx.StaticText):
0057     def __init__(self, parent, _=None):
0058         super(TimeStamp, self).__init__(parent, -1)
0059     def SetValue(self, v):
0060         if v:
0061             self.SetLabel('%04d-%02d-%02d %02d:%02d:%02d'%(
0062                 int(v[:4]), int(v[4:6]), int(v[6:8]),
0063                 int(v[9:11]), int(v[11:13]), int(v[13:])))
0064         else:
0065             self.SetLabel('')
0066 
0067 #-------------------------------------------------------------------------------
0068 class DeliveryStatus(wx.StaticText):
0069     def __init__(self, parent, _=None):
0070         super(DeliveryStatus, self).__init__(parent, -1)
0071     def SetValue(self, v):
0072         self.SetLabel('\n'.join(v))
0073 
0074 #-------------------------------------------------------------------------------
0075 class SMSInfo(pb_editor.DirtyUIBase):
0076     _dict_key_index=0
0077     _label_index=1
0078     _class_index=2
0079     _get_index=3
0080     _set_index=4
0081     _w_index=5
0082     _flg_index=6
0083     _not_used_fields={
0084         sms.SMSEntry.Folder_Inbox: ('delivery_status', '_to'),
0085         sms.SMSEntry.Folder_Sent: ('read', '_from'),
0086         sms.SMSEntry.Folder_Saved: ('delivery_status',) }
0087     def __init__(self, parent, _=None):
0088         super(SMSInfo, self).__init__(parent)
0089         self._fields=[
0090             ['_from', 'From:', StaticText, None, None, None, 0],
0091             ['_to', 'To:', StaticText, None, None, None, 0],
0092             ['callback', 'Callback #:', StaticText, None, None, None, 0],
0093             ['subject', 'Subject:', StaticText, None, None, None, 0],
0094             ['datetime', 'Date:', TimeStamp, None, None, None, 0],
0095             ['priority_str', 'Priority:', StaticText, None, None, None, 0],
0096             ['read', 'Read?:', wx.CheckBox, None, None, None, 0],
0097             ['locked', 'Locked:', wx.CheckBox, None, None, None, 0],
0098             ['delivery_status', 'Delivery Status:', DeliveryStatus, None, None,
0099              None, wx.EXPAND],
0100             ]
0101         gs=wx.FlexGridSizer(-1, 2, 5, 5)
0102         gs.AddGrowableCol(1)
0103         for n in self._fields:
0104             gs.Add(wx.StaticText(self, -1, n[self._label_index],
0105                                  style=wx.ALIGN_LEFT),0, wx.EXPAND|wx.BOTTOM, 0)
0106             w=n[self._class_index](self, -1)
0107             gs.Add(w, 0, n[self._flg_index]|wx.BOTTOM, 0)
0108             n[self._w_index]=w
0109         # all done
0110         self.SetSizer(gs)
0111         self.SetAutoLayout(True)
0112         gs.Fit(self)
0113         self._gs=gs
0114 
0115     def OnMakeDirty(self, evt):
0116         self.OnDirtyUI(evt)
0117 
0118     def Set(self, data):
0119         self.ignore_dirty=True
0120         if data is None:
0121             for n in self._fields:
0122                 if n[self._class_index]==StaticText or n[self._class_index]==DeliveryStatus or \
0123                    n[self._class_index]==TimeStamp:
0124                     w=n[self._w_index]
0125                     w.SetValue('')
0126         else:
0127             _bad_fields=self._not_used_fields.get(data.folder, ())
0128             for i,n in enumerate(self._fields):
0129                 w=n[self._w_index]
0130                 if n[self._dict_key_index] in _bad_fields:
0131                     self._gs.Show(i*2, False)
0132                     self._gs.Show(i*2+1, False)
0133                 else:
0134                     self._gs.Show(i*2, True)
0135                     self._gs.Show(i*2+1, True)
0136                     w.SetValue(getattr(data, n[self._dict_key_index]))
0137         self._gs.Layout()
0138         self.ignore_dirty=self.dirty=False
0139 
0140     def Clear(self):
0141         self.Set(None)
0142 
0143 #-------------------------------------------------------------------------------
0144 class SMSWidget(wx.Panel, widgets.BitPimWidget):
0145     _data_key='sms'
0146     _canned_data_key='canned_msg'
0147     msg_type_list=(sms.SMSEntry.Folder_Saved, sms.SMSEntry.Folder_Sent, sms.SMSEntry.Folder_Inbox)
0148     def __init__(self, mainwindow, parent):
0149         super(SMSWidget, self).__init__(parent, -1)
0150         self._main_window=mainwindow
0151         #self._data=self._canned_data={}
0152         self._data={}
0153         self._parent=parent
0154         self.sms_tree_nodes={}
0155         # main box sizer
0156         vbs=wx.BoxSizer(wx.VERTICAL)
0157         # data date adjuster
0158         hbs=wx.BoxSizer(wx.HORIZONTAL)
0159         self.read_only=False
0160         self.historical_date=None
0161         static_bs=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Historical Data Status:'),
0162                                     wx.VERTICAL)
0163         self.historical_data_label=wx.StaticText(self, -1, 'Current Data')
0164         static_bs.Add(self.historical_data_label, 1, wx.EXPAND|wx.ALL, 5)
0165         hbs.Add(static_bs, 1, wx.EXPAND|wx.ALL, 5)
0166         vbs.Add(hbs, 0, wx.EXPAND|wx.ALL, 5)
0167         static_bs1=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Canned Messages:'),
0168                                     wx.HORIZONTAL)
0169         self.canned_list=gizmos.EditableListBox(self, -1, 'User Defined Canned Messages:')
0170         static_bs1.Add(self.canned_list, 1, wx.EXPAND|wx.ALL, 5)
0171         vbs1=wx.BoxSizer(wx.VERTICAL)
0172         vbs1.Add(wx.StaticText(self, -1, '  Built-in Canned Messages:'), 0, wx.ALL, 0)
0173         self.builtin_canned_list=wx.ListBox(self, -1)
0174         vbs1.Add(self.builtin_canned_list, 1, wx.EXPAND|wx.ALL, 5)
0175         static_bs1.Add(vbs1, 1, wx.EXPAND|wx.ALL, 5)
0176         vbs.Add(static_bs1, 1, wx.EXPAND|wx.ALL, 5)
0177         self.save_btn=wx.Button(self, wx.ID_SAVE)
0178         vbs.Add(self.save_btn, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
0179         self.list_widget=SMSList(self._main_window, self._parent, self)
0180         wx.EVT_BUTTON(self, self.save_btn.GetId(), self.OnSaveCannedMsg)
0181         # all done
0182         self.SetSizer(vbs)
0183         self.SetAutoLayout(True)
0184         vbs.Fit(self)
0185 
0186     def OnInit(self):
0187         for stat in self.msg_type_list:
0188             self.sms_tree_nodes[stat]=self.AddSubPage(self.list_widget, stat, self._tree.message)
0189 
0190     def GetRightClickMenuItems(self, node):
0191         result=[]
0192         result.append((widgets.BitPimWidget.MENU_NORMAL, guihelper.ID_EXPORT_SMS, "Export SMS ...", "Export the SMS"))
0193         result.append((widgets.BitPimWidget.MENU_NORMAL, guihelper.ID_DATAHISTORICAL, "Historical Data ...", "Display Historical Data"))
0194         return result
0195 
0196     def _populate(self):
0197         self.list_widget.populate()
0198         # populate the canned data
0199         self.canned_list.SetStrings(
0200             self._canned_data.user_list)
0201         self.builtin_canned_list.Set(self._canned_data.builtin_list)
0202 
0203     def OnSaveCannedMsg(self, _):
0204         if self.read_only:
0205             wx.MessageBox('You are viewing historical data which cannot be changed or saved',
0206                           'Cannot Save SMS Data',
0207                           style=wx.OK|wx.ICON_ERROR)
0208             return
0209         self._canned_data.user_list=self.canned_list.GetStrings()
0210         self._save_to_db(canned_msg_dict=self._canned_data)
0211 
0212     def GetDeleteInfo(self):
0213         return guihelper.ART_DEL_SMS, "Delete SMS"
0214 
0215     def GetAddInfo(self):
0216         return guihelper.ART_ADD_SMS, "Add SMS"
0217 
0218     def getdata(self,dict,want=None):
0219         dict[self._data_key]=copy.deepcopy(self._data, {})
0220         dict[self._canned_data_key]=self._canned_data.get().get(
0221             self._canned_data_key, {})
0222 
0223     def get_selected_data(self):
0224         # return a dict of selected items
0225         res={}
0226         for sel_idx in self.list_widget._item_list.GetSelections().values():
0227             k=self.list_widget._item_list.GetItemData(sel_idx)
0228             if k:
0229                 res[k]=self._data[k]
0230         return res
0231 
0232     def get_data(self):
0233         return self._data
0234 
0235     def get_keys(self):
0236         """Return the list of keys as being displayed"""
0237         return self.list_widget.GetAllKeys()
0238     def get_selected_keys(self):
0239         """Return the list of keys of selected items being displayed"""
0240         return self.list_widget.GetSelectedKeys()
0241 
0242     def populate(self, dict, force=False):
0243         if self.read_only and not force:
0244             return
0245         if not self.read_only:
0246             self._canned_data=sms.CannedMsgEntry()
0247             self._canned_data.set({ self._canned_data_key: dict.get(self._canned_data_key, [])})
0248         self._data=dict.get(self._data_key, {})
0249         self._populate()
0250 
0251     def _save_to_db(self, sms_dict=None, canned_msg_dict=None):
0252         if self.read_only:
0253             return
0254         if sms_dict is not None:
0255             db_rr={}
0256             for k, e in sms_dict.items():
0257                 db_rr[k]=sms.SMSDataObject(e)
0258             database.ensurerecordtype(db_rr, sms.smsobjectfactory)
0259             self._main_window.database.savemajordict(self._data_key, db_rr)
0260         if canned_msg_dict is not None:
0261             db_rr={}
0262             db_rr[self._canned_data_key]=sms.CannedMsgDataObject(
0263                 canned_msg_dict)
0264             database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory)
0265             self._main_window.database.savemajordict(self._canned_data_key,
0266                                                       db_rr)
0267     def populatefs(self, dict):
0268         if self.read_only:
0269             wx.MessageBox('You are viewing historical data which cannot be changed or saved',
0270                           'Cannot Save SMS Data',
0271                           style=wx.OK|wx.ICON_ERROR)
0272             return
0273         canned_msg=sms.CannedMsgEntry()
0274         canned_msg.set({ self._canned_data_key: dict.get(self._canned_data_key, [])})
0275         self._save_to_db(sms_dict=dict.get(self._data_key, []),
0276                           canned_msg_dict=canned_msg)
0277         return dict
0278 
0279     def getfromfs(self, result, timestamp=None):
0280         # read data from the database
0281         sms_dict=self._main_window.database.\
0282                    getmajordictvalues(self._data_key, sms.smsobjectfactory,
0283                                       at_time=timestamp)
0284         r={}
0285         for k,e in sms_dict.items():
0286             ce=sms.SMSEntry()
0287             ce.set_db_dict(e)
0288             r[ce.id]=ce
0289         result.update({ self._data_key: r })
0290         # read the canned messages
0291         canned_msg_dict=self._main_window.database.\
0292                          getmajordictvalues(self._canned_data_key,
0293                                             sms.cannedmsgobjectfactory)
0294         for k,e in canned_msg_dict.items():
0295             ce=sms.CannedMsgEntry()
0296             ce.set_db_dict(e)
0297             result.update(ce.get())
0298         return result
0299 
0300     def merge(self, dict):
0301         # merge this data with our data
0302         # the merge criteria is simple: reject if msg_id's are same
0303         if self.read_only:
0304             wx.MessageBox('You are viewing historical data which cannot be changed or saved',
0305                           'Cannot Save SMS Data',
0306                           style=wx.OK|wx.ICON_ERROR)
0307             return
0308         existing_id=[e.msg_id for k,e in self._data.items()]
0309         d=dict.get(self._data_key, {})
0310         for k,e in d.items():
0311             if e.msg_id not in existing_id:
0312                 self._data[e.id]=e
0313         # save the canned data
0314         self._canned_data=sms.CannedMsgEntry()
0315         self._canned_data.set({ self._canned_data_key: dict.get(self._canned_data_key, []) } )
0316         # populate the display and save the data
0317         self._populate()
0318         self._save_to_db(sms_dict=self._data,
0319                          canned_msg_dict=self._canned_data)
0320 
0321     def HasHistoricalData(self):
0322         return True
0323 
0324     def OnHistoricalData(self):
0325         """Display current or historical data"""
0326         if self.read_only:
0327             current_choice=guiwidgets.HistoricalDataDialog.Historical_Data
0328         else:
0329             current_choice=guiwidgets.HistoricalDataDialog.Current_Data
0330         with guihelper.WXDialogWrapper(guiwidgets.HistoricalDataDialog(self,
0331                                                                        current_choice=current_choice,
0332                                                                        historical_date=self.historical_date,
0333                                                                        historical_events=\
0334                                                                        self._main_window.database.getchangescount(self._data_key)),
0335                                        True) as (dlg, retcode):
0336             if retcode==wx.ID_OK:
0337                 with guihelper.MWBusyWrapper(self._main_window):
0338                     current_choice, self.historical_date=dlg.GetValue()
0339                     r={}
0340                     if current_choice==guiwidgets.HistoricalDataDialog.Current_Data:
0341                         self.read_only=False
0342                         msg_str='Current Data'
0343                         self.getfromfs(r)
0344                     else:
0345                         self.read_only=True
0346                         msg_str='Historical Data as of %s'%\
0347                                  str(wx.DateTimeFromTimeT(self.historical_date))
0348                         self.getfromfs(r, self.historical_date)
0349                     self.populate(r, True)
0350                     self.historical_data_label.SetLabel(msg_str)
0351                     self.list_widget.historical_data_label.SetLabel(msg_str)
0352 
0353     def OnPrintDialog(self, mainwindow, config):
0354         with guihelper.WXDialogWrapper(guiwidgets.SMSPrintDialog(self, mainwindow, config),
0355                                        True):
0356             pass
0357     def CanPrint(self):
0358         return True
0359 
0360 #-------------------------------------------------------------------------------
0361 class SMSList(wx.Panel, widgets.BitPimWidget):
0362     _by_type=0
0363     _by_date=1
0364     _by_number=2
0365     def __init__(self, mainwindow, parent, stats):
0366         super(SMSList, self).__init__(parent, -1)
0367         self._main_window=mainwindow
0368         self._stats=stats
0369         self.nodes={}
0370         self.nodes_keys={}
0371         self._display_filter="All"
0372         self._name_map={}
0373         self._data_map={}
0374 
0375         # main box sizer
0376         vbs=wx.BoxSizer(wx.VERTICAL)
0377         # data date adjuster
0378         hbs=wx.BoxSizer(wx.HORIZONTAL)
0379         static_bs=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Historical Data Status:'),
0380                                     wx.VERTICAL)
0381         self.historical_data_label=wx.StaticText(self, -1, 'Current Data')
0382         static_bs.Add(self.historical_data_label, 1, wx.EXPAND|wx.ALL, 5)
0383         hbs.Add(static_bs, 1, wx.EXPAND|wx.ALL, 5)
0384         vbs.Add(hbs, 0, wx.EXPAND|wx.ALL, 5)
0385         # main list
0386         hbmessage=wx.BoxSizer(wx.HORIZONTAL)
0387         column_info=[]
0388         column_info.append(("From/To", 105, False))
0389         column_info.append(("Date", 120, False))
0390         column_info.append(("Subject", 180, False))
0391         self._item_list=guiwidgets.BitPimListCtrl(self, column_info)
0392         self._item_list.ResetView(self.nodes, self.nodes_keys)
0393         vbs0=wx.BoxSizer(wx.VERTICAL)
0394         vbs0.Add(self._item_list, 1, wx.EXPAND|wx.ALL, 5)
0395         vbs0.Add(wx.StaticText(self, -1, '  Note: Click column headings to sort data'), 0, wx.ALIGN_CENTRE|wx.BOTTOM, 10)
0396         hbmessage.Add(vbs0, 1, wx.EXPAND|wx.ALL, 5)
0397         vbs1=wx.BoxSizer(wx.VERTICAL)
0398         self._item_info=SMSInfo(self)
0399         vbs1.Add(self._item_info, 0, wx.EXPAND|wx.ALL, 5)
0400         self._item_text=pb_editor.MemoEditor(self, -1)
0401         vbs1.Add(self._item_text, 1, wx.EXPAND|wx.ALL, 5)
0402         hbmessage.Add(vbs1, 0, wx.EXPAND|wx.ALL, 5)
0403         hbmessage.SetItemMinSize(1, (350, 20))
0404         vbs.Add(hbmessage, 1, wx.EXPAND|wx.ALL, 5)
0405         wx.EVT_LIST_ITEM_SELECTED(self, self._item_list.GetId(), self._OnSelChanged)
0406         pubsub.subscribe(self._OnPBLookup, pubsub.RESPONSE_PB_LOOKUP)
0407         # register for Today selection
0408         self.today_data=None
0409         today.bind_notification_event(self.OnTodaySelection,
0410                                       today.Today_Group_IncomingSMS)
0411         # all done
0412         self.SetSizer(vbs)
0413         self.SetAutoLayout(True)
0414         vbs.Fit(self)
0415 
0416     def CanCopy(self):
0417         return self._item_text.CanCopy()
0418     def OnCopy(self, _):
0419         self._item_text.Copy()
0420 
0421     def OnSelected(self, node):
0422         for stat in self._stats.msg_type_list:
0423             if self._stats.sms_tree_nodes[stat]==node:
0424                 if self._display_filter!=stat:
0425                     self._display_filter=stat
0426                     # for some reason GetTopItem return 0 (instead of -1)
0427                     # when the list is empty
0428                     if self._item_list.GetItemCount():
0429                         item=self._item_list.GetTopItem()
0430                         # deselect all the items when changing view
0431                         while item!=-1:
0432                             self._item_list.Select(item, 0)
0433                             item=self._item_list.GetNextItem(item)
0434                     self._item_info.Clear()
0435                     self._item_text.Set(None)
0436                     self.populate()
0437                 self._on_today_selection()
0438                 return
0439 
0440     def GetRightClickMenuItems(self, node):
0441         result=[]
0442         result.append((widgets.BitPimWidget.MENU_NORMAL, guihelper.ID_EDITSELECTALL, "Select All", "Select All Items"))
0443         result.append((widgets.BitPimWidget.MENU_NORMAL, guihelper.ID_EDITDELETEENTRY, "Delete Selected", "Delete Selected Items"))
0444         result.append((widgets.BitPimWidget.MENU_SPACER, 0, "", ""))
0445         result.append((widgets.BitPimWidget.MENU_NORMAL, guihelper.ID_EXPORT_SMS, "Export SMS ...", "Export the SMS"))
0446         result.append((widgets.BitPimWidget.MENU_NORMAL, guihelper.ID_DATAHISTORICAL, "Historical Data ...", "Display Historical Data"))
0447         return result
0448 
0449     def CanSelectAll(self):
0450         if self._item_list.GetItemCount():
0451             return True
0452         return False
0453 
0454     def _OnPBLookup(self, msg):
0455         d=msg.data
0456         k=d.get('item', None)
0457         name=d.get('name', None)
0458         if k is None:
0459             return
0460         self._name_map[k]=name
0461 
0462     def publish_today_data(self):
0463         keys=[(x.datetime,k) for k,x in self._stats._data.items()]
0464         keys.sort()
0465         keys.reverse()
0466         today_event=today.TodaySMSEvent()
0467         for _,k in keys:
0468             if self._stats._data[k].folder==sms.SMSEntry.Folder_Inbox:
0469                 today_event.append(self._stats._data[k].text,
0470                                    { 'id': k } ) 
0471         today_event.broadcast()
0472 
0473     def OnTodaySelection(self, evt):
0474         inbox_node=self._stats.sms_tree_nodes[sms.SMSEntry.Folder_Inbox]
0475         self.today_data=evt.data
0476         self.ActivateSelf(inbox_node)
0477 
0478     def _on_today_selection(self):
0479         if self.today_data and self._item_list.GetItemCount():
0480             item=self._item_list.GetTopItem()
0481             while item>=0:
0482                 if self.today_data['id']==self._item_list.GetItemData(item):
0483                     self._item_list.Select(item, 1)
0484                     self._item_list.EnsureVisible(item)
0485                 else:
0486                     self._item_list.Select(item, 0)
0487                 item=self._item_list.GetNextItem(item)
0488         self.today_data=None
0489 
0490     def OnSelectAll(self, _):
0491         item=self._item_list.GetTopItem()
0492         while item!=-1:
0493             self._item_list.Select(item)
0494             item=self._item_list.GetNextItem(item)
0495 
0496     def _OnSelChanged(self, evt):
0497         # an item was clicked on/selected
0498         item=evt.GetIndex()
0499         k=self._item_list.GetItemData(item)
0500         # populate the detailed info of the item keyed k
0501         if k is None:
0502             # clear out all the subfields
0503             self._item_info.Clear()
0504             self._item_text.Set(None)
0505             return
0506         entry=self._stats._data.get(k, None)
0507         if entry is None:
0508             return
0509         # set the general detail
0510         e=copy.deepcopy(entry)
0511         # lookup names if available
0512         s=self._name_map.get(e._from, None)
0513         if s is None:
0514             e._from=phonenumber.format(e._from)
0515         else:
0516             e._from=s
0517         s=self._name_map.get(e._to, None)
0518         if s is None:
0519             e._to=phonenumber.format(e._to)
0520         else:
0521             e._to=s
0522         s=self._name_map.get(e.callback, None)
0523         if s is None:
0524             e.callback=phonenumber.format(e.callback)
0525         else:
0526             e.callback=s
0527         self._item_info.Set(e)
0528         self._item_text.Set({'memo': e.text})
0529 
0530     def HasHistoricalData(self):
0531         return self._stats.HasHistoricalData()
0532 
0533     def OnHistoricalData(self):
0534         return self._stats.OnHistoricalData()
0535 
0536     def populate(self):
0537         self.nodes={}
0538         self.nodes_keys={}
0539         index=0
0540         for k,e in self._stats._data.items():
0541             if len(e._from) and not self._name_map.has_key(e._from):
0542                 pubsub.publish(pubsub.REQUEST_PB_LOOKUP,
0543                                { 'item': e._from } )
0544             if len(e._to) and not self._name_map.has_key(e._to):
0545                 pubsub.publish(pubsub.REQUEST_PB_LOOKUP,
0546                                { 'item': e._to } )
0547             if len(e.callback) and not self._name_map.has_key(e.callback):
0548                 pubsub.publish(pubsub.REQUEST_PB_LOOKUP,
0549                                { 'item': e.callback } )
0550             if e.folder==self._display_filter:
0551                 col=self._item_list.GetColumn(0)
0552                 col.SetMask(wx.LIST_MASK_TEXT)
0553                 if e.folder==sms.SMSEntry.Folder_Inbox:
0554                     col.SetText("From")
0555                     name=e._from
0556                 else:
0557                     col.SetText("To")
0558                     name=e._to
0559                 self._item_list.SetColumn(0, col)
0560                 if name!=None and name!="":
0561                     temp=self._name_map.get(name, None)
0562                     if temp !=None:
0563                         name=temp
0564                 self.nodes[index]=(name, e.get_date_time_str(), e.subject)
0565                 self.nodes_keys[index]=k
0566                 self._data_map[k]=index
0567                 index+=1
0568         self._item_list.ResetView(self.nodes, self.nodes_keys)
0569         self.publish_today_data()
0570 
0571     def CanDelete(self):
0572         if self._stats.read_only:
0573             return False
0574         sels_idx=self._item_list.GetFirstSelected()
0575         if sels_idx==-1:
0576             return False
0577         return True
0578 
0579     def GetDeleteInfo(self):
0580         return guihelper.ART_DEL_SMS, "Delete Message"
0581 
0582     def OnDelete(self, _):
0583         if self._stats.read_only:
0584             return
0585         sels_idx=self._item_list.GetSelections()
0586         if len(sels_idx):
0587             # delete them from the data list
0588             for i,item in sels_idx.items():
0589                 del self._stats._data[self._item_list.GetItemData(item)]
0590                 self._item_list.Select(item, 0)
0591             self.populate()
0592             self._stats._save_to_db(self._stats._data)
0593     def GetHelpID(self):
0594         return helpids.ID_TAB_SMS
0595     def OnPrintDialog(self, mainwindow, config):
0596         self._stats.OnPrintDialog(mainwindow, config)
0597     def CanPrint(self):
0598         return True
0599     def GetAllKeys(self):
0600         return [ self._item_list.GetItemData(x) \
0601                  for x in range(self._item_list.GetItemCount()) ]
0602     def GetSelectedKeys(self):
0603         _sel_items=self._item_list.GetSelections()
0604         _keys=_sel_items.keys()
0605         _keys.sort()
0606         return [ self._item_list.GetItemData(_sel_items[x]) \
0607                  for x in _keys ]
0608 

Generated by PyXR 0.9.4