Source Code for Module conduit.hildonui.UI

  1  #!/usr/bin/env python2.5 
  2  import gtk 
  3  import hildon 
  4  import os 
  5  import logging 
  6  log = logging.getLogger("hildonui.UI") 
  7   
  8  import conduit 
  9  from conduit.hildonui.List import DataProviderBox 
 10   
 11  # FIXME: we probably should share some code between these two 
 12  from conduit.hildonui.Canvas import Canvas 
 13   
 14  from gettext import gettext as _ 
 15   
 16 -class MainWindow(hildon.Program): 
 17 -    def __init__(self, conduitApplication, moduleManager, typeConverter, syncManager): 
 18          hildon.Program.__init__(self) 
 19   
 20          #add some additional dirs to the icon theme search path so that 
 21          #modules can provider their own icons 
 22          icon_dirs = [ 
 23                      conduit.SHARED_DATA_DIR, 
 24                      conduit.SHARED_MODULE_DIR, 
 25                      os.path.join(conduit.SHARED_DATA_DIR,"icons"), 
 26                      os.path.join(conduit.USER_DIR, "modules") 
 27                      ] 
 28          for i in icon_dirs:                     
 29              gtk.icon_theme_get_default().prepend_search_path(i) 
 30              log.debug("Adding %s to icon theme search path" % (i)) 
 31   
 32          self.conduitApplication = conduitApplication 
 33          self.type_converter = typeConverter 
 34          self.sync_manager = syncManager 
 35          self.syncSet = None 
 36   
 37          self.mainWindow = hildon.Window() 
 38          self.mainWindow.set_icon_name("conduit") 
 39          # self.mainWindow.resize (800, 480) 
 40   
 41          self.mainWindow.connect("destroy", self.on_window_destroyed) 
 42          self.add_window(self.mainWindow) 
 43   
 44          self.provider_box = DataProviderBox () 
 45          self.provider_box.combo.set_active (0) 
 46   
 47          # FIXME: we should do something hildon specific 
 48          self.canvas = Canvas( 
 49                          parentWindow=self.mainWindow, 
 50                          typeConverter=self.type_converter, 
 51                          syncManager=self.sync_manager) 
 52   
 53          self.canvas.connect('drag-drop', self.drop_cb) 
 54          self.canvas.connect("drag-data-received", self.drag_data_received_data) 
 55   
 56          main_pane = gtk.HPaned () 
 57          main_pane.add1(self.provider_box) 
 58          main_pane.add2(self.canvas) 
 59          self.mainWindow.add(main_pane) 
 60   
 61 -    def set_model(self, syncSet): 
 62          self.syncSet = syncSet 
 63          self.toolbar = ConduitToolbar(self.syncSet, self.canvas) 
 64          self.canvas.set_sync_set(syncSet) 
 65           
 66          self.set_common_toolbar(self.toolbar) 
 67   
 68 -    def present(self): 
 69          """ 
 70          Present the main window. Enjoy your window 
 71          """ 
 72          self.mainWindow.show_all () 
 73   
 74 -    def minimize_to_tray(self): 
 75          """ 
 76          Iconifies the main window 
 77          """ 
 78          log.debug("Iconifying GUI") 
 79          self.mainWindow.hide() 
 80   
 81 -    def is_visible(self): 
 82          """ 
 83          Dummy for now 
 84          """ 
 85          return True 
 86   
 87 -    def drop_cb(self, wid, context, x, y, time): 
 88          """ 
 89          drop cb 
 90          """ 
 91          self.canvas.drag_get_data(context, context.targets[0], time) 
 92          return True 
 93           
 94 -    def drag_data_received_data(self, treeview, context, x, y, selection, info, etime): 
 95          """ 
 96          DND 
 97          """ 
 98          dataproviderKey = selection.data 
 99          #FIXME: DnD should be cancelled in the Treeview on the drag-begin  
100          #signal and NOT here 
101          if dataproviderKey != "": 
102              #Add a new instance if the dataprovider to the canvas. 
103              new = conduit.GLOBALS.moduleManager.get_module_wrapper_with_instance(dataproviderKey) 
104              self.canvas.add_dataprovider_to_canvas(dataproviderKey, new, x, y) 
105           
106          context.finish(True, True, etime) 
107          return 
108    
109 -    def on_window_destroyed(self, widget, event=None): 
110          """ 
111          Check if there are any synchronizations currently in progress and 
112          ask the user if they wish to cancel them 
113          """ 
114          busy = False 
115          quit = False 
116   
117          if self.syncSet: 
118              for c in self.syncSet.get_all_conduits():  
119                  if c.is_busy(): 
120                      busy = True 
121                  
122          if busy:        
123              dialog = gtk.MessageDialog( 
124                              self.mainWindow, 
125                              gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, 
126                              gtk.MESSAGE_QUESTION, 
127                              gtk.BUTTONS_YES_NO,_("Synchronization in progress. Do you want to cancel it?") 
128                              ) 
129              response = dialog.run() 
130              if response == gtk.RESPONSE_YES: 
131                  quit = True 
132              else: 
133                  #Dont exit 
134                  dialog.destroy() 
135                  return True 
136          else: 
137              quit = True 
138               
139          #OK, if we have decided to quit then call quit on the  
140          #DBus interface which will tidy up any pending running 
141          #non gui tasks 
142          if quit: 
143              log.debug("Quitting...") 
144              self.conduitApplication.Quit() 
145               
146 -    def save_settings(self, widget): 
147          pass 
148   
149 -class ConduitToolbar(gtk.Toolbar): 
150 -    def __init__(self, syncSet, canvas): 
151          gtk.Toolbar.__init__(self) 
152   
153          self.syncSet = syncSet 
154   
155          # canvas 
156          self.canvas = canvas 
157          self.canvas.connect("position-changed", self.on_position_changed) 
158   
159          # remove conduit button  
160          self.remove_button = gtk.ToolButton(gtk.STOCK_REMOVE) 
161          self.remove_button.connect("clicked", self.on_remove) 
162   
163          # save settings button 
164          self.save_button = gtk.ToolButton(gtk.STOCK_SAVE) 
165          self.save_button.connect("clicked", self.on_settings_save) 
166   
167          # sync all button 
168          image_widget = gtk.image_new_from_icon_name("conduit", 24) 
169          self.sync_button = gtk.ToolButton(icon_widget=image_widget) 
170          self.sync_button.connect("clicked", self.on_sync_all) 
171   
172          # moving 
173          self.previous_button = gtk.ToolButton(gtk.STOCK_GO_BACK) 
174          self.previous_button.connect("clicked", self.on_previous) 
175   
176          self.label = gtk.Label("0/0") 
177   
178          self.next_button = gtk.ToolButton(gtk.STOCK_GO_FORWARD) 
179          self.next_button.connect("clicked", self.on_next) 
180   
181          # add all items 
182          self.add_item (self.remove_button) 
183          self.add_item (gtk.SeparatorToolItem()) 
184          self.add_item (self.previous_button) 
185          self.add_item (self._create_toolitem(self.label)) 
186          self.add_item (self.next_button) 
187          self.add_item (gtk.SeparatorToolItem()) 
188          self.add_item (self.sync_button) 
189          self.add_item (self.save_button) 
190   
191          self.show_all ()  
192   
193 -    def add_item(self, item): 
194          self.insert (item, -1)        
195   
196 -    def on_remove (self, button): 
197          current = self.canvas.selectedConduitItem.model 
198          if not current: 
199              return 
200   
201          self.syncSet.remove_conduit(current) 
202   
203 -    def on_settings_save (self, button): 
204          self.syncSet.save_to_xml() 
205   
206 -    def on_sync_all (self, button): 
207          self.conduitApplication.Synchronize() 
208   
209 -    def on_previous (self, button): 
210          self.canvas.move_previous() 
211   
212 -    def on_next (self, button): 
213          self.canvas.move_next() 
214   
215 -    def on_position_changed(self, canvas): 
216          self.label.set_text (canvas.get_position_str()) 
217   
218 -    def _create_toolitem (self, widget): 
219          toolitem = gtk.ToolItem() 
220          toolitem.add (widget) 
221   
222          return toolitem 
223   
224 -class SplashScreen: 
225 -    def __init__(self): 
226          pass     
227   
228 -    def show(self): 
229          pass 
230   
231 -    def destroy(self): 
232          pass 
233   
234 -class StatusIcon: 
235 -    def __init__(self, conduitApplication): 
236          pass 
237   
238 -    def on_conduit_added(self, syncset, cond): 
239          pass  
240   
241 -    def on_conduit_removed(self, syncset, cond): 
242          pass 
243   
244 -    def on_click(self, status): 
245          if self.conduitApplication.HasGUI(): 
246              if self.conduitApplication.gui.is_visible(): 
247                  self.conduitApplication.gui.minimize_to_tray() 
248              else: 
249                  self.conduitApplication.gui.present() 
250          else: 
251              self.conduitApplication.BuildGUI() 
252              self.conduitApplication.ShowGUI() 
253