test/neard-ui.py

   1 #!/usr/bin/env python
   2
   3 import pdb
   4 import sys
   5
   6 import gobject
   7 import gtk
   8
   9 import dbus
  10 import dbus.service
  11 import dbus.mainloop.glib
  12
  13 import traceback
  14
  15 ##=================================================================
  16 class Neard:
  17
  18     #signal handler #1 for Manager
  19     def manager_Added(self, name):
  20         print (" Added %s") % name
  21         self.manager_getDetails()
  22
  23     #signal handler #2 for Manager
  24     def manager_Removed(self, name):
  25         print (" Removed %s") % name
  26         if self.adapters_remove is not None:
  27             self.adapter_update(name)
  28             return
  29
  30     #connect to the manager in order to be notified on
  31     #add/remove adapter
  32     def manager_Connect(self):
  33         try:
  34             manager_obj = self.sessionBus.get_object('org.neard', "/")
  35             # Add 2 handlers to follow Adapters
  36             manager_obj.connect_to_signal('AdapterAdded',
  37                                            self.manager_Added,
  38                                           'org.neard.Manager')
  39             manager_obj.connect_to_signal('AdapterRemoved',
  40                                           self.manager_Removed,
  41                                           'org.neard.Manager')
  42             self.iface_manager = dbus.Interface(manager_obj, 'org.neard.Manager')
  43
  44         except:
  45             print ("Can't connect to org.neard.Manager");
  46             self.iface_manager = None
  47         #Retrieve the manager informations
  48         self.manager_getDetails()
  49
  50     def manager_getDetails(self):
  51         #No iface_manager means adapter removed
  52         if self.iface_manager is None:
  53             if self.adapters_remove is not None:
  54                 self.adapters_remove()
  55             return
  56         #Need to update adapter's details
  57         self.adapter_updateDetails(self.iface_manager.GetProperties())
  58
  59     def adapter_PropertyChanged(self, prop, value, adapt_path = None):
  60         print("Prop changed: %s") % prop
  61         adapt_properties = {}
  62         adapt_properties[prop] = value
  63         if prop == "Targets":
  64             self.target_updateDetails(adapt_properties)
  65         else:
  66             self.adapter_update(adapt_path, adapt_properties)
  67
  68         #Update the records UI
  69     def record_updateDetails(self, target_properties):
  70          for record_path in target_properties["Records"]:
  71             print ("REC %s ") % record_path
  72             record_obj = self.systemBus.get_object('org.neard',
  73                                                      record_path)
  74             record_iface = dbus.Interface(record_obj,'org.neard.Record')
  75             record_properties = record_iface.GetProperties()
  76
  77             self.recordregistered[record_path] = True
  78
  79             # call UI update
  80             self.records_update(record_path, record_properties)
  81
  82     #Update the targets UI
  83     def target_updateDetails(self, adapt_properties):
  84         if adapt_properties["Targets"]:
  85             for target_path in adapt_properties["Targets"]:
  86                 print ("TGT %s ") % target_path
  87                 target_obj = self.systemBus.get_object('org.neard', target_path)
  88
  89                 target_iface = dbus.Interface(target_obj,'org.neard.Target')
  90                 target_properties = target_iface.GetProperties()
  91
  92                 self.targetregistered[target_path] = True
  93                 # call UI update
  94                 self.targets_update(target_path, target_properties)
  95                 #Process the records
  96                 self.record_updateDetails(target_properties)
  97         else:
  98             print ("remove targets and records")
  99             self.targets_update()
 100             self.records_update()
 101
 102
 103     #Something changed, must update the UI
 104     def adapter_updateDetails(self, properties):
 105         if self.adapter_update is not None and "Adapters" in properties:
 106             for adapt_path in properties["Adapters"]:
 107                 if adapt_path in self.adaptregistered:
 108                     print (" already registered %s") % adapt_path
 109                 else:
 110                     #Get valuable informations from the object
 111                     adapter_obj = self.systemBus.get_object('org.neard',
 112                                                          adapt_path)
 113                     adapter_obj.connect_to_signal('PropertyChanged',
 114                                                self.adapter_PropertyChanged,
 115                                                'org.neard.Adapter',
 116                                                path_keyword='adapt_path')
 117
 118                     adapt_iface = dbus.Interface(adapter_obj,'org.neard.Adapter')
 119                     adapt_properties = adapt_iface.GetProperties()
 120
 121                     self.adaptregistered[adapt_path] = True
 122
 123                     #Update display info
 124                     self.adapter_update(adapt_path, adapt_properties)
 125
 126                     #udpate UI for targets
 127                     self.target_updateDetails(adapt_properties)
 128
 129
 130     #Search DBUS to find any neard instance
 131     def neardNameOwnerChanged(self, proxy):
 132         if proxy:
 133             print("Neard is connected to session bus")
 134             self.manager_Connect()
 135         else:
 136             print("Neard is disconnected from session bus")
 137             self.iface_manager = None
 138             self.adaptregistered = {}
 139             self.manager_getDetails()
 140
 141     #Main init function
 142     def __init__(self, adapter_update = None, adapters_remove = None,
 143                   targets_update = None, records_update = None):
 144         self.test = False
 145         self.adapter_update = adapter_update
 146         self.adapters_remove = adapters_remove
 147         self.targets_update = targets_update
 148         self.records_update = records_update
 149
 150         self.adaptregistered = {}
 151         self.targetregistered = {}
 152         self.recordregistered = {}
 153
 154         self.systemBus = dbus.SessionBus()
 155
 156         #Prepare the first handler
 157         self.systemBus.watch_name_owner('org.neard',
 158                                          self.neardNameOwnerChanged)
 159
 160 ##=================================================================
 161 class NeardUI(Neard):
 162
 163     # return the current selection
 164     def adapters_actionToggle(self, i, col):
 165         if i:
 166             return self.adapters_list.get_value(i, col)
 167         return True
 168
 169     # Action: activate or not the polling mode
 170     def adapter_pollingToggled(self, poolingRendererToggle, path, user):
 171         if path:
 172             i = self.adapters_list.get_iter(path)
 173             objpath = self.adapters_list.get_value(i, 0)
 174             adapter_obj = self.systemBus.get_object('org.neard', objpath)
 175             adapt_iface = dbus.Interface(adapter_obj,'org.neard.Adapter')
 176
 177             if self.adapters_actionToggle(i, 3):
 178                 print ("Stop Polling %s") % objpath
 179                 adapt_iface.StopPoll()
 180             else:
 181                 print ("Start Polling %s") % objpath
 182                 adapt_iface.StartPoll()
 183
 184
 185     #------------------------------
 186     #Set the field values
 187     def adapters_setUIList(self, adapt_properties, i, col, name, path = None):
 188         if name in adapt_properties:
 189             value = adapt_properties[name]
 190
 191             if name == "Targets":
 192                 value = "{"
 193                 for tgts in adapt_properties[name]:
 194                     #For each target, add it to the target lbox:
 195                     #Trim path....
 196                     short_tgt = tgts[len(path)+1:]
 197
 198                     if value == "{":
 199                         value = "{" + short_tgt
 200                     else:
 201                         value = value + "," + short_tgt
 202                 value = value + "}"
 203
 204             if name == "Protocols":
 205                 value = None
 206                 for protos in adapt_properties[name]:
 207                     if value is None:
 208                         value = protos
 209                     else:
 210                         value = value + " " + protos
 211
 212             if value is not None:
 213                 self.adapters_list.set_value(i, col, value)
 214             print ("  property %s, value %s") % (name, value)
 215
 216     # Clear one or all the adapters present in list
 217     def adapter_RemoveUI(self):
 218         self.adapters_list.clear()
 219
 220     #Add, Update or delete a list entry
 221     def adapter_UpdateUI(self, path = None, adapt_properties = None):
 222         i = self.adapters_list.get_iter_first()
 223         while i is not None:
 224             if self.adapters_list.get_value(i, 0) == path:
 225                 break
 226             i = self.adapters_list.iter_next(i)
 227
 228         if adapt_properties is None:
 229             if i:
 230                 print ("Delete adapter %s") % path
 231                 self.adapters_list.remove(i)
 232             else:
 233                 print ("Already deleted adapter %s") % path
 234             return
 235
 236         if i is None:
 237             i = self.adapters_list.append()
 238             self.adapters_list.set_value(i, 0, path)
 239             print ("Add adapter %s") % (path)
 240         else:
 241             print ("Update adapter %s") % (path)
 242
 243
 244         self.adapters_setUIList(adapt_properties, i, 2, "Powered")
 245         self.adapters_setUIList(adapt_properties, i, 3, "Polling")
 246         self.adapters_setUIList(adapt_properties, i, 4, "Protocols")
 247         self.adapters_setUIList(adapt_properties, i, 5, "Targets", path)
 248
 249     #--------------------------------------------------
 250     def targets_setUIList(self, target_properties, i, col, name):
 251         if name in target_properties:
 252             value = target_properties[name]
 253
 254             if name == "Records":
 255                 value = None
 256                 for tgts in target_properties[name]:
 257                     #For each target, add it to the target lbox:
 258                     if value is None:
 259                         value = tgts
 260                     else:
 261                         value = value + "-" + tgts
 262
 263             if name == "TagType":
 264                 value = None
 265                 for tgts in target_properties[name]:
 266                     #For each target, add it to the target lbox:
 267                     if value is None:
 268                         value = tgts
 269                     else:
 270                         value = value + "-" + tgts
 271
 272             if value is not None:
 273                 self.targets_list.set_value(i, col, value)
 274             print ("  property %s, value %s") % (name, value)
 275
 276     #Add, Update or delete a list entry
 277     def target_UpdateUI(self, path = None, target_properties = None):
 278         print("Target Update %s") % path
 279         i = self.targets_list.get_iter_first()
 280         while i is not None:
 281             if self.targets_list.get_value(i, 0) == path:
 282                 break
 283             i = self.targets_list.iter_next(i)
 284
 285         #Delete mode: Remove all
 286         if target_properties is None:
 287             i = self.targets_list.get_iter_first()
 288             while i is not None:
 289                 path_name = self.targets_list.get_value(i, 0)
 290                 print ("Deleted target %s") % path_name
 291                 self.targets_list.remove(i)
 292                 if self.targets_list.iter_is_valid(i):
 293                     i = self.targets_list.iter_next(i)
 294                 else:
 295                     i = None
 296             return
 297
 298         if i is None:
 299             i = self.targets_list.append()
 300             self.targets_list.set_value(i, 0, path)
 301             print ("Add target %s") % (path)
 302         else:
 303             print ("Update target %s") % (path)
 304         self.targets_setUIList(target_properties, i, 2, "ReadOnly")
 305         self.targets_setUIList(target_properties, i, 3, "Type")
 306         self.targets_setUIList(target_properties, i, 4, "TagType")
 307         self.targets_setUIList(target_properties, i, 5, "Records")
 308
 309     #--------------------------------------------------
 310     def records_setUIList(self, record_properties, i, col, name):
 311         if name in record_properties:
 312             value = record_properties[name]
 313         else:
 314             value = ""
 315             for rec_data in record_properties:
 316                 if rec_data != "Type":
 317                      if value != "":
 318                          value = value + "\n"
 319                      value = value + rec_data + " :   " +record_properties[rec_data]
 320
 321         if value is not None:
 322             self.records_list.set_value(i, col, value)
 323         print ("  property %s, value %s") % (name, value)
 324
 325     #Add, Update or delete a list entry
 326     def record_UpdateUI(self, path = None, record_properties = None):
 327         print("Record Update %s") % path
 328         i = self.records_list.get_iter_first()
 329         while i is not None:
 330             if self.records_list.get_value(i, 0) == path:
 331                 break
 332             i = self.records_list.iter_next(i)
 333
 334          #Delete mode: Remove all records
 335         if record_properties is None:
 336             i = self.records_list.get_iter_first()
 337             while i is not None:
 338                 path_name = self.records_list.get_value(i, 0)
 339                 print ("Delete record %s") % path_name
 340                 self.records_list.remove(i)
 341                 if self.records_list.iter_is_valid(i):
 342                     i = self.records_list.iter_next(i)
 343                 else:
 344                     i = None
 345             return
 346
 347         if i is None:
 348             i = self.records_list.append()
 349             self.records_list.set_value(i, 0, path)
 350             print ("Add record %s") % (path)
 351         else:
 352             print ("Update record %s") % (path)
 353
 354         self.records_setUIList(record_properties, i, 2, "Type")
 355         self.records_setUIList(record_properties, i, 3, "Data")
 356
 357
 358     def target_RemoveUI(self):
 359         printf("Target Remove")
 360
 361     #Adapter selected on lbox
 362     def on_adapter_sel_changed(self, selection = None):
 363         model, iter = selection.get_selected()
 364         if iter:
 365              value = self.adapters_list.get_value(iter, 0)
 366              print ("value %s") % value
 367              value = self.adapters_list.get_value(iter, 5)
 368              print ("target: %s") % value
 369
 370
 371     #-----------------------------------------------------
 372     # Prepare TreeView  for Adapters
 373     def createAdaptersWidgets(self, adaptlist):
 374
 375         #treeview adapters
 376         tv_adapters = gtk.TreeView(adaptlist)
 377
 378         column = gtk.TreeViewColumn("Path", gtk.CellRendererText(), text=0)
 379         tv_adapters.append_column(column)
 380
 381         toggle = gtk.CellRendererToggle()
 382         column = gtk.TreeViewColumn("Powered", toggle, active=2)
 383         tv_adapters.append_column(column)
 384
 385         toggle = gtk.CellRendererToggle()
 386         column = gtk.TreeViewColumn("Polling", toggle, active=3)
 387         toggle.connect('toggled', self.adapter_pollingToggled, None)
 388         tv_adapters.append_column(column)
 389
 390         column = gtk.TreeViewColumn("Protocols",gtk.CellRendererText(), text=4)
 391         tv_adapters.append_column(column)
 392
 393         column = gtk.TreeViewColumn("Targets", gtk.CellRendererText(), text=5)
 394         tv_adapters.append_column(column)
 395
 396         tv_adapters.get_selection().connect("changed",
 397                                             self.on_adapter_sel_changed)
 398
 399         return tv_adapters;
 400
 401     # Prepare TreeView  for Targets
 402     def createTargetsWidgets(self, targets_list):
 403
 404
 405         tv_targets = gtk.TreeView(targets_list)
 406
 407         column = gtk.TreeViewColumn("Path", gtk.CellRendererText(), text=0)
 408         tv_targets.append_column(column)
 409         toggle = gtk.CellRendererToggle()
 410         column = gtk.TreeViewColumn("ReadOnly", toggle, active=2)
 411         tv_targets.append_column(column)
 412
 413         column = gtk.TreeViewColumn("Type", gtk.CellRendererText(), text=3)
 414         tv_targets.append_column(column)
 415
 416         column = gtk.TreeViewColumn("NFC Type ", gtk.CellRendererText(), text=4)
 417         tv_targets.append_column(column)
 418
 419         column = gtk.TreeViewColumn("Record", gtk.CellRendererText(), text=5)
 420         tv_targets.append_column(column)
 421
 422         return tv_targets;#
 423
 424     # Prepare TreeView  for Records
 425     def createRecordsWidgets(self, records_list):
 426         #treeview Records
 427         tv_records = gtk.TreeView(records_list)
 428
 429         column = gtk.TreeViewColumn("Path", gtk.CellRendererText(), text=0)
 430         tv_records.append_column(column)
 431
 432         column = gtk.TreeViewColumn("Type", gtk.CellRendererText(), text=2)
 433         tv_records.append_column(column)
 434
 435         column = gtk.TreeViewColumn("Data", gtk.CellRendererText(), text=3)
 436         tv_records.append_column(column)
 437         return tv_records;
 438
 439     def dlg_onResponse(self, dialog, response):
 440         self.neardDialog.destroy()
 441         self.neardDialog = None
 442         if self.response_callback is not None:
 443             self.response_callback(response)
 444
 445     #------------------------------
 446     #Prepare the dialog
 447     def createDialog(self, title = None):
 448         if self.title is not None:
 449             title = self.title
 450         dialog = gtk.Dialog(title, None,
 451                             gtk.DIALOG_MODAL |
 452                             gtk.DIALOG_DESTROY_WITH_PARENT,
 453                             (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
 454         dialog.set_property("resizable", True)
 455         dialog.set_default_size(800, 300)
 456
 457         notebook = gtk.Notebook()
 458         dialog.child.add(notebook)
 459
 460         # Create the first tab...an adapters's list
 461         scrolledwindow = gtk.ScrolledWindow()
 462         widget = self.createAdaptersWidgets(self.adapters_list)
 463         scrolledwindow.add(widget)
 464 #        notebook.append_page(widget, gtk.Label("Adapters"))
 465         notebook.append_page(scrolledwindow, gtk.Label("Adapters"))
 466
 467         scrolledwindow = gtk.ScrolledWindow()
 468         widget = self.createTargetsWidgets(self.targets_list)
 469         scrolledwindow.add(widget)
 470         #notebook.append_page(widget, gtk.Label("Targets"))
 471         notebook.append_page(scrolledwindow, gtk.Label("Targets"))
 472
 473         scrolledwindow = gtk.ScrolledWindow()
 474         widget = self.createRecordsWidgets(self.records_list)
 475         scrolledwindow.add(widget)
 476         notebook.append_page(scrolledwindow, gtk.Label("Records"))
 477
 478         dialog.connect('response', self.dlg_onResponse)
 479 #        dialog.vbox.pack_end(vbox, True, True, 0)
 480         return dialog
 481
 482     def show(self):
 483         if self.neardDialog is None:
 484             self.neardDialog = self.createDialog()
 485         self.neardDialog.show_all()
 486
 487     def __init__(self, title = None, response_callback = None):
 488         self.title = title
 489         self.response_callback = response_callback
 490         self.neardDialog = None
 491
 492         self.adapters_list = gtk.ListStore(gobject.TYPE_STRING,  # path =0
 493                                       gobject.TYPE_STRING,  # Name = 1
 494                                       gobject.TYPE_BOOLEAN, # powered = 2
 495                                       gobject.TYPE_BOOLEAN, # polling = 3
 496                                       gobject.TYPE_STRING,  # protocols = 4
 497                                       gobject.TYPE_STRING)  # targets = 5
 498
 499         self.targets_list = gtk.ListStore(gobject.TYPE_STRING,  # path =0
 500                                       gobject.TYPE_STRING,      # Name = 1
 501                                       gobject.TYPE_BOOLEAN,     # Read Only 2
 502                                       gobject.TYPE_STRING,      # tag Type = 3
 503                                       gobject.TYPE_STRING,      # Type = 4
 504                                       gobject.TYPE_STRING)     # Record = 5
 505
 506         self.records_list = gtk.ListStore(gobject.TYPE_STRING,  # path =0
 507                                       gobject.TYPE_STRING,      # Name = 1
 508                                       gobject.TYPE_STRING,      # Type = 2
 509                                       gobject.TYPE_STRING)        # content = 3
 510
 511         Neard.__init__(self, self.adapter_UpdateUI, self.adapter_RemoveUI
 512                        , self.target_UpdateUI, self.record_UpdateUI)
 513
 514 ##=================================================================
 515 if __name__ == "__main__":
 516
 517     def endmainloop(response):
 518         mainloop.quit()
 519
 520     dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 521     mainloop = gobject.MainLoop()
 522
 523     m = NeardUI("Neard", endmainloop)
 524     m.show()
 525
 526     mainloop.run()