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.systemBus.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 == "Tags":
  64             self.tag_updateDetails(adapt_properties)
  65         else:
  66             self.adapter_update(adapt_path, adapt_properties)
  67
  68         #Update the records UI
  69     def record_updateDetails(self, tag_properties):
  70          for record_path in tag_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 tags UI
  83     def tag_updateDetails(self, adapt_properties):
  84         if adapt_properties["Tags"]:
  85             for tag_path in adapt_properties["Tags"]:
  86                 print ("TAG %s ") % tag_path
  87                 tag_obj = self.systemBus.get_object('org.neard', tag_path)
  88
  89                 tag_iface = dbus.Interface(tag_obj,'org.neard.Tag')
  90                 tag_properties = tag_iface.GetProperties()
  91
  92                 self.tagregistered[tag_path] = True
  93                 # call UI update
  94                 self.tags_update(tag_path, tag_properties)
  95                 #Process the records
  96                 self.record_updateDetails(tag_properties)
  97         else:
  98             print ("remove tags and records")
  99             self.tags_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 tags
 127                     self.tag_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 System bus")
 134             self.manager_Connect()
 135         else:
 136             print("Neard is disconnected from System 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                   tags_update = None, records_update = None):
 144         self.test = False
 145         self.adapter_update = adapter_update
 146         self.adapters_remove = adapters_remove
 147         self.tags_update = tags_update
 148         self.records_update = records_update
 149
 150         self.adaptregistered = {}
 151         self.tagregistered = {}
 152         self.recordregistered = {}
 153
 154         self.systemBus = dbus.SystemBus()
 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.StopPollLoop()
 180             else:
 181                 print ("Start Polling %s") % objpath
 182                 adapt_iface.StartPollLoop("Initiator")
 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 == "Tags":
 192                 value = "{"
 193                 for tgts in adapt_properties[name]:
 194                     #For each tag, add it to the tag 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, "Tags", path)
 248
 249     #--------------------------------------------------
 250     def tags_setUIList(self, tag_properties, i, col, name):
 251         if name in tag_properties:
 252             value = tag_properties[name]
 253
 254             if name == "Records":
 255                 value = None
 256                 for tags in tag_properties[name]:
 257                     #For each tag, add it to the tag lbox:
 258                     if value is None:
 259                         value = tags
 260                     else:
 261                         value = value + "-" + tags
 262
 263             if name == "Type":
 264                 value = None
 265                 for tags in tag_properties[name]:
 266                     #For each tag, add it to the tag lbox:
 267                     if value is None:
 268                         value = tags
 269                     else:
 270                         value = value + "-" + tags
 271
 272             if value is not None:
 273                 self.tags_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 tag_UpdateUI(self, path = None, tag_properties = None):
 278         print("Tag Update %s") % path
 279         i = self.tags_list.get_iter_first()
 280         while i is not None:
 281             if self.tags_list.get_value(i, 0) == path:
 282                 break
 283             i = self.tags_list.iter_next(i)
 284
 285         #Delete mode: Remove all
 286         if tag_properties is None:
 287             i = self.tags_list.get_iter_first()
 288             while i is not None:
 289                 path_name = self.tags_list.get_value(i, 0)
 290                 print ("Deleted tag %s") % path_name
 291                 self.tags_list.remove(i)
 292                 if self.tags_list.iter_is_valid(i):
 293                     i = self.tags_list.iter_next(i)
 294                 else:
 295                     i = None
 296             return
 297
 298         if i is None:
 299             i = self.tags_list.append()
 300             self.tags_list.set_value(i, 0, path)
 301             print ("Add tag %s") % (path)
 302         else:
 303             print ("Update tag %s") % (path)
 304         self.tags_setUIList(tag_properties, i, 2, "ReadOnly")
 305         self.tags_setUIList(tag_properties, i, 3, "Type")
 306         self.tags_setUIList(tag_properties, i, 4, "Records")
 307
 308     #--------------------------------------------------
 309     def records_setUIList(self, record_properties, i, col, name):
 310         if name in record_properties:
 311             value = record_properties[name]
 312         else:
 313             value = ""
 314             for rec_data in record_properties:
 315                 if rec_data != "Type":
 316                      if value != "":
 317                          value = value + "\n"
 318                      value = value + rec_data + " :   " +record_properties[rec_data]
 319
 320         if value is not None:
 321             self.records_list.set_value(i, col, value)
 322         print ("  property %s, value %s") % (name, value)
 323
 324     #Add, Update or delete a list entry
 325     def record_UpdateUI(self, path = None, record_properties = None):
 326         print("Record Update %s") % path
 327         i = self.records_list.get_iter_first()
 328         while i is not None:
 329             if self.records_list.get_value(i, 0) == path:
 330                 break
 331             i = self.records_list.iter_next(i)
 332
 333          #Delete mode: Remove all records
 334         if record_properties is None:
 335             i = self.records_list.get_iter_first()
 336             while i is not None:
 337                 path_name = self.records_list.get_value(i, 0)
 338                 print ("Delete record %s") % path_name
 339                 self.records_list.remove(i)
 340                 if self.records_list.iter_is_valid(i):
 341                     i = self.records_list.iter_next(i)
 342                 else:
 343                     i = None
 344             return
 345
 346         if i is None:
 347             i = self.records_list.append()
 348             self.records_list.set_value(i, 0, path)
 349             print ("Add record %s") % (path)
 350         else:
 351             print ("Update record %s") % (path)
 352
 353         self.records_setUIList(record_properties, i, 2, "Type")
 354         self.records_setUIList(record_properties, i, 3, "Data")
 355
 356
 357     def tag_RemoveUI(self):
 358         printf("Tag Remove")
 359
 360     #Adapter selected on lbox
 361     def on_adapter_sel_changed(self, selection = None):
 362         model, iter = selection.get_selected()
 363         if iter:
 364              value = self.adapters_list.get_value(iter, 0)
 365              print ("value %s") % value
 366              value = self.adapters_list.get_value(iter, 5)
 367              print ("tag: %s") % value
 368
 369
 370     #-----------------------------------------------------
 371     # Prepare TreeView  for Adapters
 372     def createAdaptersWidgets(self, adaptlist):
 373
 374         #treeview adapters
 375         tv_adapters = gtk.TreeView(adaptlist)
 376
 377         column = gtk.TreeViewColumn("Path", gtk.CellRendererText(), text=0)
 378         tv_adapters.append_column(column)
 379
 380         toggle = gtk.CellRendererToggle()
 381         column = gtk.TreeViewColumn("Powered", toggle, active=2)
 382         tv_adapters.append_column(column)
 383
 384         toggle = gtk.CellRendererToggle()
 385         column = gtk.TreeViewColumn("Polling", toggle, active=3)
 386         toggle.connect('toggled', self.adapter_pollingToggled, None)
 387         tv_adapters.append_column(column)
 388
 389         column = gtk.TreeViewColumn("Protocols",gtk.CellRendererText(), text=4)
 390         tv_adapters.append_column(column)
 391
 392         column = gtk.TreeViewColumn("Tags", gtk.CellRendererText(), text=5)
 393         tv_adapters.append_column(column)
 394
 395         tv_adapters.get_selection().connect("changed",
 396                                             self.on_adapter_sel_changed)
 397
 398         return tv_adapters;
 399
 400     # Prepare TreeView  for Tags
 401     def createTagsWidgets(self, tags_list):
 402
 403
 404         tv_tags = gtk.TreeView(tags_list)
 405
 406         column = gtk.TreeViewColumn("Path", gtk.CellRendererText(), text=0)
 407         tv_tags.append_column(column)
 408         toggle = gtk.CellRendererToggle()
 409         column = gtk.TreeViewColumn("ReadOnly", toggle, active=2)
 410         tv_tags.append_column(column)
 411
 412         column = gtk.TreeViewColumn("Type", gtk.CellRendererText(), text=3)
 413         tv_tags.append_column(column)
 414
 415         column = gtk.TreeViewColumn("Record", gtk.CellRendererText(), text=4)
 416         tv_tags.append_column(column)
 417
 418         return tv_tags;#
 419
 420     # Prepare TreeView  for Records
 421     def createRecordsWidgets(self, records_list):
 422         #treeview Records
 423         tv_records = gtk.TreeView(records_list)
 424         tv_records.connect("row-activated", self.on_record_activated)
 425
 426         column = gtk.TreeViewColumn("Path", gtk.CellRendererText(), text=0)
 427         tv_records.append_column(column)
 428
 429         column = gtk.TreeViewColumn("Type", gtk.CellRendererText(), text=2)
 430         tv_records.append_column(column)
 431
 432         column = gtk.TreeViewColumn("Data", gtk.CellRendererText(), text=3)
 433         tv_records.append_column(column)
 434         return tv_records;
 435
 436     def on_record_activated(self, widget, row, col):
 437         model = widget.get_model()
 438         recordUI = RecordUI(self.neardDialog, model[row][0], model[row][2])
 439         recordUI.show()
 440
 441     def dlg_onResponse(self, dialog, response):
 442         self.neardDialog.destroy()
 443         self.neardDialog = None
 444         if self.response_callback is not None:
 445             self.response_callback(response)
 446
 447     #------------------------------
 448     #Prepare the dialog
 449     def createDialog(self, title = None):
 450         if self.title is not None:
 451             title = self.title
 452         dialog = gtk.Dialog(title, None,
 453                             gtk.DIALOG_MODAL |
 454                             gtk.DIALOG_DESTROY_WITH_PARENT,
 455                             (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
 456         dialog.set_property("resizable", True)
 457         dialog.set_default_size(800, 300)
 458
 459         notebook = gtk.Notebook()
 460         dialog.child.add(notebook)
 461
 462         # Create the first tab...an adapters's list
 463         scrolledwindow = gtk.ScrolledWindow()
 464         widget = self.createAdaptersWidgets(self.adapters_list)
 465         scrolledwindow.add(widget)
 466 #        notebook.append_page(widget, gtk.Label("Adapters"))
 467         notebook.append_page(scrolledwindow, gtk.Label("Adapters"))
 468
 469         scrolledwindow = gtk.ScrolledWindow()
 470         widget = self.createTagsWidgets(self.tags_list)
 471         scrolledwindow.add(widget)
 472
 473         notebook.append_page(scrolledwindow, gtk.Label("Tags"))
 474
 475         scrolledwindow = gtk.ScrolledWindow()
 476         widget = self.createRecordsWidgets(self.records_list)
 477         scrolledwindow.add(widget)
 478         notebook.append_page(scrolledwindow, gtk.Label("Records"))
 479
 480         dialog.connect('response', self.dlg_onResponse)
 481 #        dialog.vbox.pack_end(vbox, True, True, 0)
 482         return dialog
 483
 484     def show(self):
 485         if self.neardDialog is None:
 486             self.neardDialog = self.createDialog()
 487         self.neardDialog.show_all()
 488
 489     def __init__(self, title = None, response_callback = None):
 490         self.title = title
 491         self.response_callback = response_callback
 492         self.neardDialog = None
 493
 494         self.adapters_list = gtk.ListStore(gobject.TYPE_STRING,  # path =0
 495                                       gobject.TYPE_STRING,  # Name = 1
 496                                       gobject.TYPE_BOOLEAN, # powered = 2
 497                                       gobject.TYPE_BOOLEAN, # polling = 3
 498                                       gobject.TYPE_STRING,  # protocols = 4
 499                                       gobject.TYPE_STRING)  # tags = 5
 500
 501         self.tags_list = gtk.ListStore(gobject.TYPE_STRING,  # path =0
 502                                       gobject.TYPE_STRING,      # Name = 1
 503                                       gobject.TYPE_BOOLEAN,     # Read Only 2
 504                                       gobject.TYPE_STRING,      # Type = 3
 505                                       gobject.TYPE_STRING)     # Record = 4
 506
 507         self.records_list = gtk.ListStore(gobject.TYPE_STRING,  # path =0
 508                                       gobject.TYPE_STRING,      # Name = 1
 509                                       gobject.TYPE_STRING,      # Type = 2
 510                                       gobject.TYPE_STRING)        # content = 3
 511
 512         Neard.__init__(self, self.adapter_UpdateUI, self.adapter_RemoveUI
 513                        , self.tag_UpdateUI, self.record_UpdateUI)
 514
 515 class RecordUI():
 516     def wr_onResponse(self, dialog, response):
 517         if response != gtk.RESPONSE_ACCEPT:
 518             return
 519         content = self.content_entry.get_text()
 520         type_name = self.type_combo.get_active_text()
 521         bus = dbus.SystemBus()
 522         record_path = self.path
 523         tag_path = record_path[:record_path.rfind("/")]
 524         tag = dbus.Interface(bus.get_object("org.neard", tag_path), "org.neard.Tag")
 525         if type_name in ["Text"]:
 526             content1 = content.split()
 527             tag.Write({"Type" : type_name,
 528                       "Encoding" : content1[0],
 529                       "Language" : content1[1],
 530                       "Representation" : ' '.join(content1[2:])})
 531         else:
 532             tag.Write({"Type" : type_name,
 533                        "URI" : content})
 534         dialog.destroy()
 535
 536     def __init__(self, parent = None, path = None, type_name = None):
 537         self.path = path
 538         type_combo = gtk.combo_box_new_text()
 539         type_combo.append_text('Text')
 540         type_combo.append_text('URI')
 541         type_combo.append_text('SmartPoster')
 542         if type_name == 'Text':
 543             type_combo.set_active(0)
 544         elif type_name == 'URI':
 545             type_combo.set_active(1)
 546         elif type_name == 'SmartPoster':
 547             type_combo.set_active(2)
 548         fixed = gtk.Fixed()
 549         content_entry = gtk.Entry()
 550         fixed.put(type_combo, 20, 40)
 551         fixed.put(content_entry, 150, 40)
 552         type_label = gtk.Label("Type")
 553         content_label = gtk.Label("Content")
 554         fixed.put(type_label, 20, 15)
 555         fixed.put(content_label, 150, 15)
 556
 557         record_dialog = gtk.Dialog("Write Record", parent,
 558                         gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
 559                         (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
 560         self.record_dialog = record_dialog
 561         record_dialog.set_default_size(280, 120)
 562         record_dialog.set_position(gtk.WIN_POS_CENTER)
 563         record_dialog.connect('response', self.wr_onResponse)
 564         hbox = record_dialog.get_content_area()
 565         hbox.pack_start(fixed)
 566         self.type_combo = type_combo
 567         self.content_entry = content_entry
 568         fixed.show_all()
 569
 570     def show(self):
 571         self.record_dialog.run()
 572         self.record_dialog.destroy()
 573
 574 ##=================================================================
 575 if __name__ == "__main__":
 576
 577     def endmainloop(response):
 578         mainloop.quit()
 579
 580     dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 581     mainloop = gobject.MainLoop()
 582
 583     m = NeardUI("Neard", endmainloop)
 584     m.show()
 585
 586     mainloop.run()