git.maemo.org Git - watersofshiloah/blob - src/windows.py

   1 # @todo Add icons to buttons/rows to indicate that the currently playing track is coming from that
   2
   3 import ConfigParser
   4 import datetime
   5 import logging
   6
   7 import gobject
   8 import gtk
   9
  10 import constants
  11 import hildonize
  12 import util.misc as misc_utils
  13
  14 import banners
  15 import playcontrol
  16 import presenter
  17
  18
  19 _moduleLogger = logging.getLogger(__name__)
  20
  21
  22 class BasicWindow(gobject.GObject):
  23
  24         __gsignals__ = {
  25                 'quit' : (
  26                         gobject.SIGNAL_RUN_LAST,
  27                         gobject.TYPE_NONE,
  28                         (),
  29                 ),
  30                 'fullscreen' : (
  31                         gobject.SIGNAL_RUN_LAST,
  32                         gobject.TYPE_NONE,
  33                         (gobject.TYPE_PYOBJECT, ),
  34                 ),
  35         }
  36
  37         def __init__(self, player, store, index):
  38                 gobject.GObject.__init__(self)
  39                 self._isDestroyed = False
  40
  41                 self._player = player
  42                 self._store = store
  43                 self._index = index
  44
  45                 self._clipboard = gtk.clipboard_get()
  46                 self._windowInFullscreen = False
  47
  48                 self._errorBanner = banners.StackingBanner()
  49
  50                 self._layout = gtk.VBox()
  51                 self._layout.pack_start(self._errorBanner.toplevel, False, True)
  52
  53                 self._window = gtk.Window()
  54                 self._window.add(self._layout)
  55                 self._window = hildonize.hildonize_window(self, self._window)
  56
  57                 self._window.set_icon(self._store.get_pixbuf_from_store(self._store.STORE_LOOKUP["icon"]))
  58                 self._window.connect("key-press-event", self._on_key_press)
  59                 self._window.connect("window-state-event", self._on_window_state_change)
  60                 self._window.connect("destroy", self._on_destroy)
  61
  62         @property
  63         def window(self):
  64                 return self._window
  65
  66         def save_settings(self, config, sectionName):
  67                 config.add_section(sectionName)
  68                 config.set(sectionName, "fullscreen", str(self._windowInFullscreen))
  69
  70         def load_settings(self, config, sectionName):
  71                 try:
  72                         self._windowInFullscreen = config.getboolean(sectionName, "fullscreen")
  73                 except ConfigParser.NoSectionError, e:
  74                         _moduleLogger.info(
  75                                 "Settings file %s is missing section %s" % (
  76                                         constants._user_settings_,
  77                                         e.section,
  78                                 )
  79                         )
  80
  81                 if self._windowInFullscreen:
  82                         self._window.fullscreen()
  83                 else:
  84                         self._window.unfullscreen()
  85
  86         @misc_utils.log_exception(_moduleLogger)
  87         def _on_destroy(self, *args):
  88                 self._isDestroyed = True
  89
  90         @misc_utils.log_exception(_moduleLogger)
  91         def _on_window_state_change(self, widget, event, *args):
  92                 if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
  93                         self._windowInFullscreen = True
  94                 else:
  95                         self._windowInFullscreen = False
  96                 self.emit("fullscreen", self._windowInFullscreen)
  97
  98         @misc_utils.log_exception(_moduleLogger)
  99         def _on_key_press(self, widget, event, *args):
 100                 RETURN_TYPES = (gtk.keysyms.Return, gtk.keysyms.ISO_Enter, gtk.keysyms.KP_Enter)
 101                 isCtrl = bool(event.get_state() & gtk.gdk.CONTROL_MASK)
 102                 if (
 103                         event.keyval == gtk.keysyms.F6 or
 104                         event.keyval in RETURN_TYPES and isCtrl
 105                 ):
 106                         # The "Full screen" hardware key has been pressed
 107                         if self._windowInFullscreen:
 108                                 self._window.unfullscreen ()
 109                         else:
 110                                 self._window.fullscreen ()
 111                         return True
 112                 elif (
 113                         event.keyval in (gtk.keysyms.w, ) and
 114                         event.get_state() & gtk.gdk.CONTROL_MASK
 115                 ):
 116                         self._window.destroy()
 117                 elif (
 118                         event.keyval in (gtk.keysyms.q, ) and
 119                         event.get_state() & gtk.gdk.CONTROL_MASK
 120                 ):
 121                         self.emit("quit")
 122                 elif event.keyval == gtk.keysyms.l and event.get_state() & gtk.gdk.CONTROL_MASK:
 123                         with open(constants._user_logpath_, "r") as f:
 124                                 logLines = f.xreadlines()
 125                                 log = "".join(logLines)
 126                                 self._clipboard.set_text(str(log))
 127                         return True
 128
 129
 130 class SourceSelector(BasicWindow):
 131
 132         def __init__(self, player, store, index):
 133                 self._languages = []
 134
 135                 BasicWindow.__init__(self, player, store, index)
 136
 137                 self._loadingBanner = banners.GenericBanner()
 138
 139                 self._radioButton = self._create_button("radio", "Radio")
 140                 self._radioButton.connect("clicked", self._on_source_selected, RadioWindow)
 141                 self._radioWrapper = gtk.VBox()
 142                 self._radioWrapper.pack_start(self._radioButton, False, True)
 143
 144                 self._conferenceButton = self._create_button("conferences", "Conferences")
 145                 self._conferenceButton.connect("clicked", self._on_source_selected, ConferencesWindow)
 146                 self._conferenceWrapper = gtk.VBox()
 147                 self._conferenceWrapper.pack_start(self._conferenceButton, False, True)
 148
 149                 self._magazineButton = self._create_button("magazines", "Magazines")
 150                 #self._magazineButton.connect("clicked", self._on_source_selected)
 151                 self._magazineWrapper = gtk.VBox()
 152                 self._magazineWrapper.pack_start(self._magazineButton, False, True)
 153
 154                 self._scriptureButton = self._create_button("scriptures", "Scriptures")
 155                 #self._scriptureButton.connect("clicked", self._on_source_selected)
 156                 self._scriptureWrapper = gtk.VBox()
 157                 self._scriptureWrapper.pack_start(self._scriptureButton, False, True)
 158
 159                 self._buttonLayout = gtk.VButtonBox()
 160                 self._buttonLayout.set_layout(gtk.BUTTONBOX_SPREAD)
 161                 self._buttonLayout.pack_start(self._radioWrapper, True, True)
 162                 self._buttonLayout.pack_start(self._conferenceWrapper, True, True)
 163                 self._buttonLayout.pack_start(self._magazineWrapper, True, True)
 164                 self._buttonLayout.pack_start(self._scriptureWrapper, True, True)
 165
 166                 self._playcontrol = playcontrol.PlayControl(player, store)
 167
 168                 self._layout.pack_start(self._loadingBanner.toplevel, False, False)
 169                 self._layout.pack_start(self._buttonLayout, True, True)
 170                 self._layout.pack_start(self._playcontrol.toplevel, False, True)
 171
 172                 self._window.set_title(constants.__pretty_app_name__)
 173                 self._window.show_all()
 174                 self._errorBanner.toplevel.hide()
 175                 self._playcontrol.toplevel.hide()
 176
 177                 self._refresh()
 178
 179         def _show_loading(self):
 180                 animationPath = self._store.STORE_LOOKUP["loading"]
 181                 animation = self._store.get_pixbuf_animation_from_store(animationPath)
 182                 self._loadingBanner.show(animation, "Loading...")
 183                 self._buttonLayout.set_sensitive(False)
 184
 185         def _hide_loading(self):
 186                 self._loadingBanner.hide()
 187                 self._buttonLayout.set_sensitive(True)
 188
 189         def _refresh(self):
 190                 self._show_loading()
 191                 self._index.download(
 192                         "get_languages",
 193                         self._on_languages,
 194                         self._on_error,
 195                 )
 196
 197         def _create_button(self, icon, message):
 198                 image = self._store.get_image_from_store(self._store.STORE_LOOKUP[icon])
 199
 200                 label = gtk.Label()
 201                 label.set_text(message)
 202
 203                 buttonLayout = gtk.HBox(False, 5)
 204                 buttonLayout.pack_start(image, False, False)
 205                 buttonLayout.pack_start(label, False, True)
 206                 button = gtk.Button()
 207                 button.add(buttonLayout)
 208
 209                 return button
 210
 211         @misc_utils.log_exception(_moduleLogger)
 212         def _on_languages(self, languages):
 213                 self._hide_loading()
 214                 self._languages = list(languages)
 215
 216         @misc_utils.log_exception(_moduleLogger)
 217         def _on_error(self, exception):
 218                 self._hide_loading()
 219                 self._errorBanner.push_message(exception)
 220
 221         @misc_utils.log_exception(_moduleLogger)
 222         def _on_source_selected(self, widget, Source):
 223                 sourceWindow = Source(self._player, self._store, self._index, self._languages[0]["id"])
 224                 sourceWindow.window.set_modal(True)
 225                 sourceWindow.window.set_transient_for(self._window)
 226                 sourceWindow.window.set_default_size(*self._window.get_size())
 227
 228
 229 gobject.type_register(SourceSelector)
 230
 231
 232 class RadioWindow(BasicWindow):
 233
 234         def __init__(self, player, store, index, languageId):
 235                 BasicWindow.__init__(self, player, store, index)
 236
 237                 self._loadingBanner = banners.GenericBanner()
 238
 239                 headerPath = self._store.STORE_LOOKUP["radio_header"]
 240                 self._header = self._store.get_image_from_store(headerPath)
 241                 self._headerNavigation = presenter.NavigationBox()
 242                 self._headerNavigation.toplevel.add(self._header)
 243                 self._headerNavigation.connect("action", self._on_nav_action)
 244
 245
 246                 self._programmingModel = gtk.ListStore(
 247                         gobject.TYPE_STRING,
 248                         gobject.TYPE_STRING,
 249                 )
 250
 251                 textrenderer = gtk.CellRendererText()
 252                 timeColumn = gtk.TreeViewColumn("Time")
 253                 timeColumn.pack_start(textrenderer, expand=True)
 254                 timeColumn.add_attribute(textrenderer, "text", 0)
 255
 256                 textrenderer = gtk.CellRendererText()
 257                 titleColumn = gtk.TreeViewColumn("Program")
 258                 titleColumn.pack_start(textrenderer, expand=True)
 259                 titleColumn.add_attribute(textrenderer, "text", 1)
 260
 261                 self._treeView = gtk.TreeView()
 262                 self._treeView.set_headers_visible(False)
 263                 self._treeView.set_model(self._programmingModel)
 264                 self._treeView.append_column(timeColumn)
 265                 self._treeView.append_column(titleColumn)
 266                 self._treeView.get_selection().connect("changed", self._on_row_changed)
 267
 268                 self._treeScroller = gtk.ScrolledWindow()
 269                 self._treeScroller.add(self._treeView)
 270                 self._treeScroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 271
 272                 self._presenter = presenter.StreamMiniPresenter(self._player, self._store)
 273                 self._presenterNavigation = presenter.NavigationBox()
 274                 self._presenterNavigation.toplevel.add(self._presenter.toplevel)
 275                 self._presenterNavigation.connect("action", self._on_nav_action)
 276
 277                 self._radioLayout = gtk.VBox(False)
 278                 self._radioLayout.pack_start(self._headerNavigation.toplevel, False, False)
 279                 self._radioLayout.pack_start(self._treeScroller, True, True)
 280                 self._radioLayout.pack_start(self._presenterNavigation.toplevel, False, True)
 281
 282                 self._layout.pack_start(self._loadingBanner.toplevel, False, False)
 283                 self._layout.pack_start(self._radioLayout, True, True)
 284
 285                 self._window.set_title("Radio")
 286                 self._window.show_all()
 287                 self._errorBanner.toplevel.hide()
 288                 self._loadingBanner.toplevel.hide()
 289
 290                 self._dateShown = datetime.datetime.now()
 291                 self._refresh()
 292
 293         def _show_loading(self):
 294                 animationPath = self._store.STORE_LOOKUP["loading"]
 295                 animation = self._store.get_pixbuf_animation_from_store(animationPath)
 296                 self._loadingBanner.show(animation, "Loading...")
 297
 298         def _hide_loading(self):
 299                 self._loadingBanner.hide()
 300
 301         def _refresh(self):
 302                 self._show_loading()
 303                 self._programmingModel.clear()
 304                 self._index.download(
 305                         "get_radio_channels",
 306                         self._on_channels,
 307                         self._on_load_error,
 308                 )
 309
 310         def _get_current_row(self):
 311                 nowTime = self._dateShown.strftime("%H:%M:%S")
 312                 i = 0
 313                 for i, row in enumerate(self._programmingModel):
 314                         if nowTime < row[0]:
 315                                 if i == 0:
 316                                         return 0
 317                                 else:
 318                                         return i - 1
 319                 else:
 320                         return i
 321
 322         @misc_utils.log_exception(_moduleLogger)
 323         def _on_nav_action(self, widget, navState):
 324                 if navState == "clicking":
 325                         pass
 326                 elif navState == "down":
 327                         self.window.destroy()
 328                 elif navState == "up":
 329                         pass
 330                 elif navState == "left":
 331                         self._dateShown += datetime.timedelta(days=1)
 332                         self._refresh()
 333                 elif navState == "right":
 334                         self._dateShown -= datetime.timedelta(days=1)
 335                         self._refresh()
 336
 337         @misc_utils.log_exception(_moduleLogger)
 338         def _on_channels(self, channels):
 339                 if self._isDestroyed:
 340                         _moduleLogger.info("Download complete but window destroyed")
 341                         return
 342
 343                 channels = list(channels)
 344                 if 1 < len(channels):
 345                         _moduleLogger.warning("More channels now available!")
 346                 channel = channels[0]
 347                 self._index.download(
 348                         "get_radio_channel_programming",
 349                         self._on_channel,
 350                         self._on_load_error,
 351                         channel["id"],
 352                         self._dateShown,
 353                 )
 354
 355         @misc_utils.log_exception(_moduleLogger)
 356         def _on_channel(self, programs):
 357                 if self._isDestroyed:
 358                         _moduleLogger.info("Download complete but window destroyed")
 359                         return
 360
 361                 self._hide_loading()
 362                 for program in programs:
 363                         row = program["time"], program["title"]
 364                         self._programmingModel.append(row)
 365
 366                 path = (self._get_current_row(), )
 367                 self._treeView.scroll_to_cell(path)
 368                 self._treeView.get_selection().select_path(path)
 369
 370         @misc_utils.log_exception(_moduleLogger)
 371         def _on_load_error(self, exception):
 372                 self._hide_loading()
 373                 self._errorBanner.push_message(exception)
 374
 375         @misc_utils.log_exception(_moduleLogger)
 376         def _on_row_changed(self, selection):
 377                 if len(self._programmingModel) == 0:
 378                         return
 379
 380                 rowIndex = self._get_current_row()
 381                 path = (rowIndex, )
 382                 if not selection.path_is_selected(path):
 383                         # Undo the user's changing of the selection
 384                         selection.select_path(path)
 385
 386
 387 gobject.type_register(RadioWindow)
 388
 389
 390 class ListWindow(BasicWindow):
 391
 392         def __init__(self, player, store, index):
 393                 BasicWindow.__init__(self, player, store, index)
 394
 395                 self._loadingBanner = banners.GenericBanner()
 396
 397                 modelTypes, columns = zip(*self._get_columns())
 398
 399                 self._model = gtk.ListStore(*modelTypes)
 400
 401                 self._treeView = gtk.TreeView()
 402                 self._treeView.connect("row-activated", self._on_row_activated)
 403                 self._treeView.set_headers_visible(False)
 404                 self._treeView.set_model(self._model)
 405                 for column in columns:
 406                         if column is not None:
 407                                 self._treeView.append_column(column)
 408
 409                 self._treeScroller = gtk.ScrolledWindow()
 410                 self._treeScroller.add(self._treeView)
 411                 self._treeScroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 412
 413                 self._playcontrol = playcontrol.PlayControl(self._player, self._store)
 414
 415                 self._contentLayout = gtk.VBox(False)
 416                 self._contentLayout.pack_start(self._treeScroller, True, True)
 417                 self._contentLayout.pack_start(self._playcontrol.toplevel, False, True)
 418
 419                 self._layout.pack_start(self._loadingBanner.toplevel, False, False)
 420                 self._layout.pack_start(self._contentLayout, True, True)
 421
 422                 self._window.show_all()
 423                 self._errorBanner.toplevel.hide()
 424                 self._loadingBanner.toplevel.hide()
 425
 426                 self._refresh()
 427                 self._playcontrol.refresh()
 428
 429         @classmethod
 430         def _get_columns(cls):
 431                 raise NotImplementedError("")
 432
 433         def _get_current_row(self):
 434                 raise NotImplementedError("")
 435
 436         @misc_utils.log_exception(_moduleLogger)
 437         def _on_row_activated(self, view, path, column):
 438                 raise NotImplementedError("")
 439
 440         def _show_loading(self):
 441                 animationPath = self._store.STORE_LOOKUP["loading"]
 442                 animation = self._store.get_pixbuf_animation_from_store(animationPath)
 443                 self._loadingBanner.show(animation, "Loading...")
 444
 445         def _hide_loading(self):
 446                 self._loadingBanner.hide()
 447
 448         def _refresh(self):
 449                 self._show_loading()
 450                 self._model.clear()
 451
 452         def _select_row(self):
 453                 path = (self._get_current_row(), )
 454                 self._treeView.scroll_to_cell(path)
 455                 self._treeView.get_selection().select_path(path)
 456
 457
 458 class ConferencesWindow(ListWindow):
 459
 460         def __init__(self, player, store, index, languageId):
 461                 self._languageId = languageId
 462
 463                 ListWindow.__init__(self, player, store, index)
 464                 self._window.set_title("Conferences")
 465
 466         @classmethod
 467         def _get_columns(cls):
 468                 yield gobject.TYPE_STRING, None
 469
 470                 textrenderer = gtk.CellRendererText()
 471                 column = gtk.TreeViewColumn("Date")
 472                 column.pack_start(textrenderer, expand=True)
 473                 column.add_attribute(textrenderer, "text", 1)
 474                 yield gobject.TYPE_STRING, column
 475
 476                 textrenderer = gtk.CellRendererText()
 477                 column = gtk.TreeViewColumn("Conference")
 478                 column.pack_start(textrenderer, expand=True)
 479                 column.add_attribute(textrenderer, "text", 2)
 480                 yield gobject.TYPE_STRING, column
 481
 482         def _get_current_row(self):
 483                 # @todo Not implemented yet
 484                 return 0
 485
 486         def _refresh(self):
 487                 ListWindow._refresh(self)
 488                 self._index.download(
 489                         "get_conferences",
 490                         self._on_conferences,
 491                         self._on_error,
 492                         self._languageId,
 493                 )
 494
 495         @misc_utils.log_exception(_moduleLogger)
 496         def _on_conferences(self, programs):
 497                 if self._isDestroyed:
 498                         _moduleLogger.info("Download complete but window destroyed")
 499                         return
 500
 501                 self._hide_loading()
 502                 for program in programs:
 503                         row = program["id"], program["title"], program["full_title"]
 504                         self._model.append(row)
 505
 506                 path = (self._get_current_row(), )
 507                 self._treeView.scroll_to_cell(path)
 508                 self._treeView.get_selection().select_path(path)
 509
 510         @misc_utils.log_exception(_moduleLogger)
 511         def _on_error(self, exception):
 512                 self._hide_loading()
 513                 self._errorBanner.push_message(exception)
 514
 515         @misc_utils.log_exception(_moduleLogger)
 516         def _on_row_activated(self, view, path, column):
 517                 itr = self._model.get_iter(path)
 518                 conferenceId = self._model.get_value(itr, 0)
 519
 520                 sessionsWindow = ConferenceSessionsWindow(self._player, self._store, self._index, conferenceId)
 521                 sessionsWindow.window.set_modal(True)
 522                 sessionsWindow.window.set_transient_for(self._window)
 523                 sessionsWindow.window.set_default_size(*self._window.get_size())
 524
 525
 526 gobject.type_register(ConferencesWindow)
 527
 528
 529 class ConferenceSessionsWindow(ListWindow):
 530
 531         def __init__(self, player, store, index, conferenceId):
 532                 self._conferenceId = conferenceId
 533
 534                 ListWindow.__init__(self, player, store, index)
 535                 self._window.set_title("Sessions")
 536
 537         @classmethod
 538         def _get_columns(cls):
 539                 yield gobject.TYPE_STRING, None
 540
 541                 textrenderer = gtk.CellRendererText()
 542                 column = gtk.TreeViewColumn("Session")
 543                 column.pack_start(textrenderer, expand=True)
 544                 column.add_attribute(textrenderer, "text", 1)
 545                 yield gobject.TYPE_STRING, column
 546
 547         def _get_current_row(self):
 548                 # @todo Not implemented yet
 549                 return 0
 550
 551         def _refresh(self):
 552                 ListWindow._refresh(self)
 553                 self._index.download(
 554                         "get_conference_sessions",
 555                         self._on_conference_sessions,
 556                         self._on_error,
 557                         self._conferenceId,
 558                 )
 559
 560         @misc_utils.log_exception(_moduleLogger)
 561         def _on_conference_sessions(self, programs):
 562                 if self._isDestroyed:
 563                         _moduleLogger.info("Download complete but window destroyed")
 564                         return
 565
 566                 self._hide_loading()
 567                 for program in programs:
 568                         row = program["id"], program["title"]
 569                         self._model.append(row)
 570
 571                 path = (self._get_current_row(), )
 572                 self._treeView.scroll_to_cell(path)
 573                 self._treeView.get_selection().select_path(path)
 574
 575         @misc_utils.log_exception(_moduleLogger)
 576         def _on_error(self, exception):
 577                 self._hide_loading()
 578                 self._errorBanner.push_message(exception)
 579
 580         @misc_utils.log_exception(_moduleLogger)
 581         def _on_row_activated(self, view, path, column):
 582                 itr = self._model.get_iter(path)
 583                 sessionId = self._model.get_value(itr, 0)
 584
 585                 sessionsWindow = ConferenceTalksWindow(self._player, self._store, self._index, sessionId)
 586                 sessionsWindow.window.set_modal(True)
 587                 sessionsWindow.window.set_transient_for(self._window)
 588                 sessionsWindow.window.set_default_size(*self._window.get_size())
 589
 590
 591 gobject.type_register(ConferenceSessionsWindow)
 592
 593
 594 class ConferenceTalksWindow(ListWindow):
 595
 596         def __init__(self, player, store, index, sessionId):
 597                 self._sessionId = sessionId
 598
 599                 ListWindow.__init__(self, player, store, index)
 600                 self._window.set_title("Talks")
 601
 602         @classmethod
 603         def _get_columns(cls):
 604                 yield gobject.TYPE_STRING, None
 605
 606                 textrenderer = gtk.CellRendererText()
 607                 column = gtk.TreeViewColumn("Talk")
 608                 column.pack_start(textrenderer, expand=True)
 609                 column.add_attribute(textrenderer, "text", 1)
 610                 yield gobject.TYPE_STRING, column
 611
 612         def _get_current_row(self):
 613                 # @todo Not implemented yet
 614                 return 0
 615
 616         def _refresh(self):
 617                 ListWindow._refresh(self)
 618                 self._index.download(
 619                         "get_conference_talks",
 620                         self._on_conference_talks,
 621                         self._on_error,
 622                         self._sessionId,
 623                 )
 624
 625         @misc_utils.log_exception(_moduleLogger)
 626         def _on_conference_talks(self, programs):
 627                 if self._isDestroyed:
 628                         _moduleLogger.info("Download complete but window destroyed")
 629                         return
 630
 631                 self._hide_loading()
 632                 for program in programs:
 633                         row = program["id"], "%s\n%s" % (program["title"], program["speaker"])
 634                         self._model.append(row)
 635
 636                 path = (self._get_current_row(), )
 637                 self._treeView.scroll_to_cell(path)
 638                 self._treeView.get_selection().select_path(path)
 639
 640         @misc_utils.log_exception(_moduleLogger)
 641         def _on_error(self, exception):
 642                 self._hide_loading()
 643                 self._errorBanner.push_message(exception)
 644
 645         @misc_utils.log_exception(_moduleLogger)
 646         def _on_row_activated(self, view, path, column):
 647                 raise NotImplementedError("")
 648
 649
 650 gobject.type_register(ConferenceTalksWindow)