git.maemo.org Git - gonvert/blob - src/hildonize.py

   1 #!/usr/bin/env python
   2
   3 """
   4 Open Issues
   5         @bug not all of a message is shown
   6         @bug Buttons are too small
   7 """
   8
   9
  10 import gobject
  11 import gtk
  12 import dbus
  13
  14
  15 class _NullHildonModule(object):
  16         pass
  17
  18
  19 try:
  20         import hildon as _hildon
  21         hildon  = _hildon # Dumb but gets around pyflakiness
  22 except (ImportError, OSError):
  23         hildon = _NullHildonModule
  24
  25
  26 IS_HILDON_SUPPORTED = hildon is not _NullHildonModule
  27
  28
  29 class _NullHildonProgram(object):
  30
  31         def add_window(self, window):
  32                 pass
  33
  34
  35 def _hildon_get_app_class():
  36         return hildon.Program
  37
  38
  39 def _null_get_app_class():
  40         return _NullHildonProgram
  41
  42
  43 try:
  44         hildon.Program
  45         get_app_class = _hildon_get_app_class
  46 except AttributeError:
  47         get_app_class = _null_get_app_class
  48
  49
  50 def _hildon_set_application_title(window, title):
  51         pass
  52
  53
  54 def _null_set_application_title(window, title):
  55         window.set_title(title)
  56
  57
  58 if IS_HILDON_SUPPORTED:
  59         set_application_title = _hildon_set_application_title
  60 else:
  61         set_application_title = _null_set_application_title
  62
  63
  64 def _fremantle_hildonize_window(app, window):
  65         oldWindow = window
  66         newWindow = hildon.StackableWindow()
  67         oldWindow.get_child().reparent(newWindow)
  68         app.add_window(newWindow)
  69         oldWindow.destroy()
  70         return newWindow
  71
  72
  73 def _hildon_hildonize_window(app, window):
  74         oldWindow = window
  75         newWindow = hildon.Window()
  76         oldWindow.get_child().reparent(newWindow)
  77         app.add_window(newWindow)
  78         oldWindow.destroy()
  79         return newWindow
  80
  81
  82 def _null_hildonize_window(app, window):
  83         return window
  84
  85
  86 try:
  87         hildon.StackableWindow
  88         hildonize_window = _fremantle_hildonize_window
  89 except AttributeError:
  90         try:
  91                 hildon.Window
  92                 hildonize_window = _hildon_hildonize_window
  93         except AttributeError:
  94                 hildonize_window = _null_hildonize_window
  95
  96
  97 def _fremantle_hildonize_menu(window, gtkMenu, buttons):
  98         appMenu = hildon.AppMenu()
  99         for button in buttons:
 100                 appMenu.append(button)
 101         window.set_app_menu(appMenu)
 102         gtkMenu.get_parent().remove(gtkMenu)
 103         return appMenu
 104
 105
 106 def _hildon_hildonize_menu(window, gtkMenu, ignoredButtons):
 107         hildonMenu = gtk.Menu()
 108         for child in gtkMenu.get_children():
 109                 child.reparent(hildonMenu)
 110         window.set_menu(hildonMenu)
 111         gtkMenu.destroy()
 112         return hildonMenu
 113
 114
 115 def _null_hildonize_menu(window, gtkMenu, ignoredButtons):
 116         return gtkMenu
 117
 118
 119 try:
 120         hildon.AppMenu
 121         GTK_MENU_USED = False
 122         IS_FREMANTLE_SUPPORTED = True
 123         hildonize_menu = _fremantle_hildonize_menu
 124 except AttributeError:
 125         GTK_MENU_USED = True
 126         IS_FREMANTLE_SUPPORTED = False
 127         if IS_HILDON_SUPPORTED:
 128                 hildonize_menu = _hildon_hildonize_menu
 129         else:
 130                 hildonize_menu = _null_hildonize_menu
 131
 132
 133 def _hildon_set_button_auto_selectable(button):
 134         button.set_theme_size(hildon.HILDON_SIZE_AUTO_HEIGHT)
 135
 136
 137 def _null_set_button_auto_selectable(button):
 138         pass
 139
 140
 141 try:
 142         hildon.HILDON_SIZE_AUTO_HEIGHT
 143         gtk.Button.set_theme_size
 144         set_button_auto_selectable = _hildon_set_button_auto_selectable
 145 except AttributeError:
 146         set_button_auto_selectable = _null_set_button_auto_selectable
 147
 148
 149 def _hildon_set_button_finger_selectable(button):
 150         button.set_theme_size(hildon.HILDON_SIZE_FINGER_HEIGHT)
 151
 152
 153 def _null_set_button_finger_selectable(button):
 154         pass
 155
 156
 157 try:
 158         hildon.HILDON_SIZE_FINGER_HEIGHT
 159         gtk.Button.set_theme_size
 160         set_button_finger_selectable = _hildon_set_button_finger_selectable
 161 except AttributeError:
 162         set_button_finger_selectable = _null_set_button_finger_selectable
 163
 164
 165 def _hildon_set_button_thumb_selectable(button):
 166         button.set_theme_size(hildon.HILDON_SIZE_THUMB_HEIGHT)
 167
 168
 169 def _null_set_button_thumb_selectable(button):
 170         pass
 171
 172
 173 try:
 174         hildon.HILDON_SIZE_THUMB_HEIGHT
 175         gtk.Button.set_theme_size
 176         set_button_thumb_selectable = _hildon_set_button_thumb_selectable
 177 except AttributeError:
 178         set_button_thumb_selectable = _null_set_button_thumb_selectable
 179
 180
 181 def _hildon_set_cell_thumb_selectable(renderer):
 182         renderer.set_property("scale", 1.5)
 183
 184
 185 def _null_set_cell_thumb_selectable(renderer):
 186         pass
 187
 188
 189 if IS_HILDON_SUPPORTED:
 190         set_cell_thumb_selectable = _hildon_set_cell_thumb_selectable
 191 else:
 192         set_cell_thumb_selectable = _null_set_cell_thumb_selectable
 193
 194
 195 def _fremantle_show_information_banner(parent, message):
 196         hildon.hildon_banner_show_information(parent, "", message)
 197
 198
 199 def _hildon_show_information_banner(parent, message):
 200         hildon.hildon_banner_show_information(parent, None, message)
 201
 202
 203 def _null_show_information_banner(parent, message):
 204         pass
 205
 206
 207 if IS_FREMANTLE_SUPPORTED:
 208         show_information_banner = _fremantle_show_information_banner
 209 else:
 210         try:
 211                 hildon.hildon_banner_show_information
 212                 show_information_banner = _hildon_show_information_banner
 213         except AttributeError:
 214                 show_information_banner = _null_show_information_banner
 215
 216
 217 def _fremantle_show_busy_banner_start(parent, message):
 218         hildon.hildon_gtk_window_set_progress_indicator(parent, True)
 219         return parent
 220
 221
 222 def _fremantle_show_busy_banner_end(banner):
 223         hildon.hildon_gtk_window_set_progress_indicator(banner, False)
 224
 225
 226 def _hildon_show_busy_banner_start(parent, message):
 227         return hildon.hildon_banner_show_animation(parent, None, message)
 228
 229
 230 def _hildon_show_busy_banner_end(banner):
 231         banner.destroy()
 232
 233
 234 def _null_show_busy_banner_start(parent, message):
 235         return None
 236
 237
 238 def _null_show_busy_banner_end(banner):
 239         assert banner is None
 240
 241
 242 try:
 243         hildon.hildon_gtk_window_set_progress_indicator
 244         show_busy_banner_start = _fremantle_show_busy_banner_start
 245         show_busy_banner_end = _fremantle_show_busy_banner_end
 246 except AttributeError:
 247         try:
 248                 hildon.hildon_banner_show_animation
 249                 show_busy_banner_start = _hildon_show_busy_banner_start
 250                 show_busy_banner_end = _hildon_show_busy_banner_end
 251         except AttributeError:
 252                 show_busy_banner_start = _null_show_busy_banner_start
 253                 show_busy_banner_end = _null_show_busy_banner_end
 254
 255
 256 def _hildon_hildonize_text_entry(textEntry):
 257         textEntry.set_property('hildon-input-mode', 7)
 258
 259
 260 def _null_hildonize_text_entry(textEntry):
 261         pass
 262
 263
 264 if IS_HILDON_SUPPORTED:
 265         hildonize_text_entry = _hildon_hildonize_text_entry
 266 else:
 267         hildonize_text_entry = _null_hildonize_text_entry
 268
 269
 270 def _hildon_mark_window_rotatable(window):
 271         # gtk documentation is unclear whether this does a "=" or a "|="
 272         window.set_flags(hildon.HILDON_PORTRAIT_MODE_SUPPORT)
 273
 274
 275 def _null_mark_window_rotatable(window):
 276         pass
 277
 278
 279 try:
 280         hildon.HILDON_PORTRAIT_MODE_SUPPORT
 281         mark_window_rotatable = _hildon_mark_window_rotatable
 282 except AttributeError:
 283         mark_window_rotatable = _null_mark_window_rotatable
 284
 285
 286 def _hildon_window_to_portrait(window):
 287         # gtk documentation is unclear whether this does a "=" or a "|="
 288         window.set_flags(hildon.HILDON_PORTRAIT_MODE_SUPPORT)
 289
 290
 291 def _hildon_window_to_landscape(window):
 292         # gtk documentation is unclear whether this does a "=" or a "&= ~"
 293         window.unset_flags(hildon.HILDON_PORTRAIT_MODE_REQUEST)
 294
 295
 296 def _null_window_to_portrait(window):
 297         pass
 298
 299
 300 def _null_window_to_landscape(window):
 301         pass
 302
 303
 304 try:
 305         hildon.HILDON_PORTRAIT_MODE_SUPPORT
 306         hildon.HILDON_PORTRAIT_MODE_REQUEST
 307
 308         window_to_portrait = _hildon_window_to_portrait
 309         window_to_landscape = _hildon_window_to_landscape
 310 except AttributeError:
 311         window_to_portrait = _null_window_to_portrait
 312         window_to_landscape = _null_window_to_landscape
 313
 314
 315 def get_device_orientation():
 316         bus = dbus.SystemBus()
 317         try:
 318                 rawMceRequest = bus.get_object("com.nokia.mce", "/com/nokia/mce/request")
 319                 mceRequest = dbus.Interface(rawMceRequest, dbus_interface="com.nokia.mce.request")
 320                 orientation, standState, faceState, xAxis, yAxis, zAxis = mceRequest.get_device_orientation()
 321         except dbus.exception.DBusException:
 322                 # catching for documentation purposes that when a system doesn't
 323                 # support this, this is what to expect
 324                 raise
 325
 326         if orientation == "":
 327                 return gtk.ORIENTATION_HORIZONTAL
 328         elif orientation == "":
 329                 return gtk.ORIENTATION_VERTICAL
 330         else:
 331                 raise RuntimeError("Unknown orientation: %s" % orientation)
 332
 333
 334 def _hildon_hildonize_password_entry(textEntry):
 335         textEntry.set_property('hildon-input-mode', 7 | (1 << 29))
 336
 337
 338 def _null_hildonize_password_entry(textEntry):
 339         pass
 340
 341
 342 if IS_HILDON_SUPPORTED:
 343         hildonize_password_entry = _hildon_hildonize_password_entry
 344 else:
 345         hildonize_password_entry = _null_hildonize_password_entry
 346
 347
 348 def _hildon_hildonize_combo_entry(comboEntry):
 349         comboEntry.set_property('hildon-input-mode', 1 << 4)
 350
 351
 352 def _null_hildonize_combo_entry(textEntry):
 353         pass
 354
 355
 356 if IS_HILDON_SUPPORTED:
 357         hildonize_combo_entry = _hildon_hildonize_combo_entry
 358 else:
 359         hildonize_combo_entry = _null_hildonize_combo_entry
 360
 361
 362 def _fremantle_hildonize_scrollwindow(scrolledWindow):
 363         pannableWindow = hildon.PannableArea()
 364
 365         child = scrolledWindow.get_child()
 366         scrolledWindow.remove(child)
 367         pannableWindow.add(child)
 368
 369         parent = scrolledWindow.get_parent()
 370         parent.remove(scrolledWindow)
 371         parent.add(pannableWindow)
 372
 373         return pannableWindow
 374
 375
 376 def _hildon_hildonize_scrollwindow(scrolledWindow):
 377         hildon.hildon_helper_set_thumb_scrollbar(scrolledWindow, True)
 378         return scrolledWindow
 379
 380
 381 def _null_hildonize_scrollwindow(scrolledWindow):
 382         return scrolledWindow
 383
 384
 385 try:
 386         hildon.PannableArea
 387         hildonize_scrollwindow = _fremantle_hildonize_scrollwindow
 388         hildonize_scrollwindow_with_viewport = _hildon_hildonize_scrollwindow
 389 except AttributeError:
 390         try:
 391                 hildon.hildon_helper_set_thumb_scrollbar
 392                 hildonize_scrollwindow = _hildon_hildonize_scrollwindow
 393                 hildonize_scrollwindow_with_viewport = _hildon_hildonize_scrollwindow
 394         except AttributeError:
 395                 hildonize_scrollwindow = _null_hildonize_scrollwindow
 396                 hildonize_scrollwindow_with_viewport = _null_hildonize_scrollwindow
 397
 398
 399 def _hildon_request_number(parent, title, range, default):
 400         spinner = hildon.NumberEditor(*range)
 401         spinner.set_value(default)
 402
 403         dialog = gtk.Dialog(
 404                 title,
 405                 parent,
 406                 gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
 407                 (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL),
 408         )
 409         dialog.set_default_response(gtk.RESPONSE_CANCEL)
 410         dialog.get_child().add(spinner)
 411
 412         try:
 413                 dialog.show_all()
 414                 response = dialog.run()
 415
 416                 if response == gtk.RESPONSE_OK:
 417                         return spinner.get_value()
 418                 elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
 419                         raise RuntimeError("User cancelled request")
 420                 else:
 421                         raise RuntimeError("Unrecognized response %r", response)
 422         finally:
 423                 dialog.hide()
 424                 dialog.destroy()
 425
 426
 427 def _null_request_number(parent, title, range, default):
 428         adjustment = gtk.Adjustment(default, range[0], range[1], 1, 5, 0)
 429         spinner = gtk.SpinButton(adjustment, 0, 0)
 430         spinner.set_wrap(False)
 431
 432         dialog = gtk.Dialog(
 433                 title,
 434                 parent,
 435                 gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
 436                 (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL),
 437         )
 438         dialog.set_default_response(gtk.RESPONSE_CANCEL)
 439         dialog.get_child().add(spinner)
 440
 441         try:
 442                 dialog.show_all()
 443                 response = dialog.run()
 444
 445                 if response == gtk.RESPONSE_OK:
 446                         return spinner.get_value_as_int()
 447                 elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
 448                         raise RuntimeError("User cancelled request")
 449                 else:
 450                         raise RuntimeError("Unrecognized response %r", response)
 451         finally:
 452                 dialog.hide()
 453                 dialog.destroy()
 454
 455
 456 try:
 457         hildon.NumberEditor # TODO deprecated in fremantle
 458         request_number = _hildon_request_number
 459 except AttributeError:
 460         request_number = _null_request_number
 461
 462
 463 def _hildon_touch_selector(parent, title, items, defaultIndex):
 464         model = gtk.ListStore(gobject.TYPE_STRING)
 465         for item in items:
 466                 model.append((item, ))
 467
 468         selector = hildon.TouchSelector()
 469         selector.append_text_column(model, True)
 470         selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
 471         selector.set_active(0, defaultIndex)
 472
 473         dialog = hildon.PickerDialog(parent)
 474         dialog.set_selector(selector)
 475
 476         try:
 477                 dialog.show_all()
 478                 response = dialog.run()
 479
 480                 if response == gtk.RESPONSE_OK:
 481                         return selector.get_active(0)
 482                 elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
 483                         raise RuntimeError("User cancelled request")
 484                 else:
 485                         raise RuntimeError("Unrecognized response %r", response)
 486         finally:
 487                 dialog.hide()
 488                 dialog.destroy()
 489
 490
 491 def _on_null_touch_selector_activated(treeView, path, column, dialog, pathData):
 492         dialog.response(gtk.RESPONSE_OK)
 493         pathData[0] = path
 494
 495
 496 def _null_touch_selector(parent, title, items, defaultIndex = -1):
 497         parentSize = parent.get_size()
 498
 499         model = gtk.ListStore(gobject.TYPE_STRING)
 500         for item in items:
 501                 model.append((item, ))
 502
 503         cell = gtk.CellRendererText()
 504         set_cell_thumb_selectable(cell)
 505         column = gtk.TreeViewColumn(title)
 506         column.pack_start(cell, expand=True)
 507         column.add_attribute(cell, "text", 0)
 508
 509         treeView = gtk.TreeView()
 510         treeView.set_model(model)
 511         treeView.append_column(column)
 512         selection = treeView.get_selection()
 513         selection.set_mode(gtk.SELECTION_SINGLE)
 514         if 0 < defaultIndex:
 515                 selection.select_path((defaultIndex, ))
 516
 517         scrolledWin = gtk.ScrolledWindow()
 518         scrolledWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 519         scrolledWin.add(treeView)
 520
 521         dialog = gtk.Dialog(
 522                 title,
 523                 parent,
 524                 gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
 525                 (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL),
 526         )
 527         dialog.set_default_response(gtk.RESPONSE_CANCEL)
 528         dialog.get_child().add(scrolledWin)
 529         dialog.resize(parentSize[0], max(parentSize[1]-100, 100))
 530
 531         scrolledWin = hildonize_scrollwindow(scrolledWin)
 532         pathData = [None]
 533         treeView.connect("row-activated", _on_null_touch_selector_activated, dialog, pathData)
 534
 535         try:
 536                 dialog.show_all()
 537                 response = dialog.run()
 538
 539                 if response == gtk.RESPONSE_OK:
 540                         if pathData[0] is None:
 541                                 raise RuntimeError("No selection made")
 542                         return pathData[0][0]
 543                 elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
 544                         raise RuntimeError("User cancelled request")
 545                 else:
 546                         raise RuntimeError("Unrecognized response %r", response)
 547         finally:
 548                 dialog.hide()
 549                 dialog.destroy()
 550
 551
 552 try:
 553         hildon.PickerDialog
 554         hildon.TouchSelector
 555         touch_selector = _hildon_touch_selector
 556 except AttributeError:
 557         touch_selector = _null_touch_selector
 558
 559
 560 def _hildon_touch_selector_entry(parent, title, items, defaultItem):
 561         # Got a segfault when using append_text_column with TouchSelectorEntry, so using this way
 562         try:
 563                 selector = hildon.TouchSelectorEntry(text=True)
 564         except TypeError:
 565                 selector = hildon.hildon_touch_selector_entry_new_text()
 566         defaultIndex = -1
 567         for i, item in enumerate(items):
 568                 selector.append_text(item)
 569                 if item == defaultItem:
 570                         defaultIndex = i
 571
 572         dialog = hildon.PickerDialog(parent)
 573         dialog.set_selector(selector)
 574
 575         if 0 < defaultIndex:
 576                 selector.set_active(0, defaultIndex)
 577         else:
 578                 selector.get_entry().set_text(defaultItem)
 579
 580         try:
 581                 dialog.show_all()
 582                 response = dialog.run()
 583         finally:
 584                 dialog.hide()
 585
 586         if response == gtk.RESPONSE_OK:
 587                 return selector.get_entry().get_text()
 588         elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
 589                 raise RuntimeError("User cancelled request")
 590         else:
 591                 raise RuntimeError("Unrecognized response %r", response)
 592
 593
 594 def _on_null_touch_selector_entry_entry_changed(entry, result, selection, defaultIndex):
 595         custom = entry.get_text().strip()
 596         if custom:
 597                 result[0] = custom
 598                 selection.unselect_all()
 599         else:
 600                 result[0] = None
 601                 selection.select_path((defaultIndex, ))
 602
 603
 604 def _on_null_touch_selector_entry_entry_activated(customEntry, dialog, result):
 605         dialog.response(gtk.RESPONSE_OK)
 606         result[0] = customEntry.get_text()
 607
 608
 609 def _on_null_touch_selector_entry_tree_activated(treeView, path, column, dialog, result):
 610         dialog.response(gtk.RESPONSE_OK)
 611         model = treeView.get_model()
 612         itr = model.get_iter(path)
 613         if itr is not None:
 614                 result[0] = model.get_value(itr, 0)
 615
 616
 617 def _null_touch_selector_entry(parent, title, items, defaultItem):
 618         parentSize = parent.get_size()
 619
 620         model = gtk.ListStore(gobject.TYPE_STRING)
 621         defaultIndex = -1
 622         for i, item in enumerate(items):
 623                 model.append((item, ))
 624                 if item == defaultItem:
 625                         defaultIndex = i
 626
 627         cell = gtk.CellRendererText()
 628         set_cell_thumb_selectable(cell)
 629         column = gtk.TreeViewColumn(title)
 630         column.pack_start(cell, expand=True)
 631         column.add_attribute(cell, "text", 0)
 632
 633         treeView = gtk.TreeView()
 634         treeView.set_model(model)
 635         treeView.append_column(column)
 636         selection = treeView.get_selection()
 637         selection.set_mode(gtk.SELECTION_SINGLE)
 638
 639         scrolledWin = gtk.ScrolledWindow()
 640         scrolledWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 641         scrolledWin.add(treeView)
 642
 643         customEntry = gtk.Entry()
 644
 645         layout = gtk.VBox()
 646         layout.pack_start(customEntry, expand=False)
 647         layout.pack_start(scrolledWin)
 648
 649         dialog = gtk.Dialog(
 650                 title,
 651                 parent,
 652                 gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
 653                 (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL),
 654         )
 655         dialog.set_default_response(gtk.RESPONSE_CANCEL)
 656         dialog.get_child().add(layout)
 657         dialog.resize(parentSize[0], max(parentSize[1]-100, 100))
 658
 659         scrolledWin = hildonize_scrollwindow(scrolledWin)
 660
 661         result = [None]
 662         if 0 < defaultIndex:
 663                 selection.select_path((defaultIndex, ))
 664                 result[0] = defaultItem
 665         else:
 666                 customEntry.set_text(defaultItem)
 667
 668         customEntry.connect("activate", _on_null_touch_selector_entry_entry_activated, dialog, result)
 669         customEntry.connect("changed", _on_null_touch_selector_entry_entry_changed, result, selection, defaultIndex)
 670         treeView.connect("row-activated", _on_null_touch_selector_entry_tree_activated, dialog, result)
 671
 672         try:
 673                 dialog.show_all()
 674                 response = dialog.run()
 675
 676                 if response == gtk.RESPONSE_OK:
 677                         _, itr = selection.get_selected()
 678                         if itr is not None:
 679                                 return model.get_value(itr, 0)
 680                         else:
 681                                 enteredText = customEntry.get_text().strip()
 682                                 if enteredText:
 683                                         return enteredText
 684                                 elif result[0] is not None:
 685                                         return result[0]
 686                                 else:
 687                                         raise RuntimeError("No selection made")
 688                 elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
 689                         raise RuntimeError("User cancelled request")
 690                 else:
 691                         raise RuntimeError("Unrecognized response %r", response)
 692         finally:
 693                 dialog.hide()
 694                 dialog.destroy()
 695
 696
 697 try:
 698         hildon.PickerDialog
 699         hildon.TouchSelectorEntry
 700         touch_selector_entry = _hildon_touch_selector_entry
 701 except AttributeError:
 702         touch_selector_entry = _null_touch_selector_entry
 703
 704
 705 if __name__ == "__main__":
 706         app = get_app_class()()
 707
 708         label = gtk.Label("Hello World from a Label!")
 709
 710         win = gtk.Window()
 711         win.add(label)
 712         win = hildonize_window(app, win)
 713         if False:
 714                 print touch_selector(win, "Test", ["A", "B", "C", "D"], 2)
 715         if True:
 716                 print touch_selector_entry(win, "Test", ["A", "B", "C", "D"], "C")
 717                 print touch_selector_entry(win, "Test", ["A", "B", "C", "D"], "Blah")
 718         if False:
 719                 import pprint
 720                 name, value = "", ""
 721                 goodLocals = [
 722                         (name, value) for (name, value) in locals().iteritems()
 723                         if not name.startswith("_")
 724                 ]
 725                 pprint.pprint(goodLocals)
 726         if False:
 727                 import time
 728                 show_information_banner(win, "Hello World")
 729                 time.sleep(5)
 730         if False:
 731                 import time
 732                 banner = show_busy_banner_start(win, "Hello World")
 733                 time.sleep(5)
 734                 show_busy_banner_end(banner)