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

   1 import datetime
   2 import logging
   3
   4 import gobject
   5 import gtk
   6
   7 import hildonize
   8 import util.misc as misc_utils
   9 import util.time_utils as time_utils
  10 import util.go_utils as go_utils
  11 import banners
  12 import presenter
  13
  14 import windows
  15
  16
  17 _moduleLogger = logging.getLogger(__name__)
  18
  19
  20 class RadioWindow(windows._base.BasicWindow):
  21
  22         def __init__(self, app, player, store, node):
  23                 windows._base.BasicWindow.__init__(self, app, player, store)
  24                 self._node = node
  25                 self._childNode = None
  26
  27                 self.connect_auto(self._player, "state-change", self._on_player_state_change)
  28                 self.connect_auto(self._player, "title-change", self._on_player_title_change)
  29
  30                 self._loadingBanner = banners.GenericBanner()
  31
  32                 headerPath = self._store.STORE_LOOKUP["radio_header"]
  33                 self._header = self._store.get_image_from_store(headerPath)
  34                 self._headerNavigation = presenter.NavigationBox()
  35                 self._headerNavigation.toplevel.add(self._header)
  36                 self._headerNavigation.connect("action", self._on_nav_action)
  37                 self._headerNavigation.connect("navigating", self._on_navigating)
  38
  39                 self._programmingModel = gtk.ListStore(
  40                         gobject.TYPE_STRING,
  41                         gobject.TYPE_STRING,
  42                 )
  43
  44                 textrenderer = gtk.CellRendererText()
  45                 timeColumn = gtk.TreeViewColumn("Time")
  46                 textrenderer.set_property("scale", 0.75)
  47                 timeColumn.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
  48                 timeColumn.set_property("fixed-width", 80)
  49                 timeColumn.pack_start(textrenderer, expand=True)
  50                 timeColumn.add_attribute(textrenderer, "text", 0)
  51
  52                 textrenderer = gtk.CellRendererText()
  53                 titleColumn = gtk.TreeViewColumn("Program")
  54                 titleColumn.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
  55                 titleColumn.pack_start(textrenderer, expand=True)
  56                 titleColumn.add_attribute(textrenderer, "text", 1)
  57
  58                 self._treeView = gtk.TreeView()
  59                 self._treeView.set_property("fixed-height-mode", True)
  60                 self._treeView.set_headers_visible(False)
  61                 self._treeView.set_model(self._programmingModel)
  62                 self._treeView.append_column(timeColumn)
  63                 self._treeView.append_column(titleColumn)
  64                 self._treeView.get_selection().connect("changed", self._on_row_changed)
  65
  66                 self._viewport = gtk.Viewport()
  67                 self._viewport.add(self._treeView)
  68
  69                 self._treeScroller = gtk.ScrolledWindow()
  70                 self._treeScroller.add(self._viewport)
  71                 self._treeScroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
  72                 self._treeScroller = hildonize.hildonize_scrollwindow(self._treeScroller)
  73
  74                 self._presenter = presenter.StreamMiniPresenter(self._store)
  75                 self._presenterNavigation = presenter.NavigationBox()
  76                 self._presenterNavigation.toplevel.add(self._presenter.toplevel)
  77                 self._presenterNavigation.connect("action", self._on_nav_action)
  78                 self._presenterNavigation.connect("navigating", self._on_navigating)
  79
  80                 self._radioLayout = gtk.VBox(False)
  81                 self._radioLayout.pack_start(self._headerNavigation.toplevel, False, False)
  82                 self._radioLayout.pack_start(self._treeScroller, True, True)
  83                 self._radioLayout.pack_start(self._presenterNavigation.toplevel, False, True)
  84
  85                 self._layout.pack_start(self._loadingBanner.toplevel, False, False)
  86                 self._layout.pack_start(self._radioLayout, True, True)
  87
  88                 self._dateShown = datetime.datetime.now(tz=time_utils.Mountain)
  89                 self._update_title()
  90
  91         def show(self):
  92                 windows._base.BasicWindow.show(self)
  93
  94                 self._errorBanner.toplevel.hide()
  95                 self._loadingBanner.toplevel.hide()
  96
  97                 self._refresh()
  98
  99         def jump_to(self, node):
 100                 _moduleLogger.info("Only 1 channel, nothing to jump to")
 101
 102         def _update_title(self):
 103                 self._window.set_title("%s - %s" % (self._node.title, self._dateShown.strftime("%m/%d")))
 104
 105         @property
 106         def _active(self):
 107                 return self._player.node is self._childNode
 108
 109         def _set_context(self, state):
 110                 if state == self._player.STATE_PLAY:
 111                         if self._active:
 112                                 self._presenter.set_state(self._store.STORE_LOOKUP["pause"])
 113                         else:
 114                                 self._presenter.set_state(self._store.STORE_LOOKUP["play"])
 115                 elif state == self._player.STATE_PAUSE:
 116                         self._presenter.set_state(self._store.STORE_LOOKUP["play"])
 117                 elif state == self._player.STATE_STOP:
 118                         self._presenter.set_state(self._store.STORE_LOOKUP["play"])
 119                 else:
 120                         _moduleLogger.info("Unhandled player state %s" % state)
 121                         self._presenter.set_state(self._store.STORE_LOOKUP["play"])
 122
 123         def _show_loading(self):
 124                 animationPath = self._store.STORE_LOOKUP["loading"]
 125                 animation = self._store.get_pixbuf_animation_from_store(animationPath)
 126                 self._loadingBanner.show(animation, "Loading...")
 127
 128         def _hide_loading(self):
 129                 self._loadingBanner.hide()
 130
 131         def _refresh(self):
 132                 self._show_loading()
 133                 self._programmingModel.clear()
 134                 self._node.get_children(
 135                         self._on_channels,
 136                         self._on_load_error,
 137                 )
 138                 self._set_context(self._player.state)
 139
 140         def _get_current_row(self):
 141                 nowTime = self._dateShown.strftime("%H:%M:%S")
 142                 i = 0
 143                 for i, row in enumerate(self._programmingModel):
 144                         if nowTime < row[0]:
 145                                 if i == 0:
 146                                         return 0
 147                                 else:
 148                                         return i - 1
 149                 else:
 150                         return i
 151
 152         @misc_utils.log_exception(_moduleLogger)
 153         def _on_player_state_change(self, player, newState):
 154                 if self._headerNavigation.is_active() or self._presenterNavigation.is_active():
 155                         return
 156
 157                 self._set_context(newState)
 158
 159         @misc_utils.log_exception(_moduleLogger)
 160         def _on_player_title_change(self, player, node):
 161                 if node is not self._childNode or node is None:
 162                         _moduleLogger.info("Player title magically changed to %s" % player.title)
 163                         return
 164
 165         @misc_utils.log_exception(_moduleLogger)
 166         def _on_navigating(self, widget, navState):
 167                 if navState == "clicking":
 168                         if self._player.state == self._player.STATE_PLAY:
 169                                 if self._active:
 170                                         imageName = "pause_pressed"
 171                                 else:
 172                                         imageName = "play_pressed"
 173                         elif self._player.state == self._player.STATE_PAUSE:
 174                                 imageName = "play_pressed"
 175                         elif self._player.state == self._player.STATE_STOP:
 176                                 imageName = "play_pressed"
 177                         else:
 178                                 imageName = "play_pressed"
 179                                 _moduleLogger.info("Unhandled player state %s" % self._player.state)
 180                 elif navState == "down":
 181                         imageName = "home"
 182                 else:
 183                         if self._player.state == self._player.STATE_PLAY:
 184                                 imageName = "pause"
 185                         else:
 186                                 imageName = "play"
 187
 188                 self._presenter.set_state(self._store.STORE_LOOKUP[imageName])
 189
 190         @misc_utils.log_exception(_moduleLogger)
 191         def _on_nav_action(self, widget, navState):
 192                 self._set_context(self._player.state)
 193
 194                 if navState == "clicking":
 195                         if self._player.state == self._player.STATE_PLAY:
 196                                 if self._active:
 197                                         self._player.pause()
 198                                 else:
 199                                         self._player.set_piece_by_node(self._childNode)
 200                                         self._player.play()
 201                         elif self._player.state == self._player.STATE_PAUSE:
 202                                 self._player.play()
 203                         elif self._player.state == self._player.STATE_STOP:
 204                                 self._player.set_piece_by_node(self._childNode)
 205                                 self._player.play()
 206                         else:
 207                                 _moduleLogger.info("Unhandled player state %s" % self._player.state)
 208                 elif navState == "down":
 209                         self.window.destroy()
 210                 elif navState == "up":
 211                         pass
 212                 elif navState == "left":
 213                         self._dateShown += datetime.timedelta(days=1)
 214                         self._update_title()
 215                         self._refresh()
 216                 elif navState == "right":
 217                         self._dateShown -= datetime.timedelta(days=1)
 218                         self._update_title()
 219                         self._refresh()
 220
 221         @misc_utils.log_exception(_moduleLogger)
 222         def _on_channels(self, channels):
 223                 if self._isDestroyed:
 224                         _moduleLogger.info("Download complete but window destroyed")
 225                         return
 226
 227                 channels = channels
 228                 if 1 < len(channels):
 229                         _moduleLogger.warning("More channels now available!")
 230                 self._childNode = channels[0]
 231                 self._childNode.get_programming(
 232                         self._dateShown,
 233                         self._on_channel,
 234                         self._on_load_error,
 235                 )
 236
 237         @misc_utils.log_exception(_moduleLogger)
 238         def _on_channel(self, programs):
 239                 if self._isDestroyed:
 240                         _moduleLogger.info("Download complete but window destroyed")
 241                         return
 242
 243                 self._hide_loading()
 244                 for program in programs:
 245                         row = program["time"], program["title"]
 246                         self._programmingModel.append(row)
 247
 248                 currentDate = datetime.datetime.now()
 249                 if currentDate.date() != self._dateShown.date():
 250                         self._treeView.get_selection().set_mode(gtk.SELECTION_NONE)
 251                 else:
 252                         self._treeView.get_selection().set_mode(gtk.SELECTION_SINGLE)
 253                         self._select_row()
 254                         go_utils.Async(self._on_delay_scroll).start()
 255
 256         @misc_utils.log_exception(_moduleLogger)
 257         def _on_delay_scroll(self, *args):
 258                 self._scroll_to_row()
 259
 260         @misc_utils.log_exception(_moduleLogger)
 261         def _on_load_error(self, exception):
 262                 self._hide_loading()
 263                 self._errorBanner.push_message(str(exception))
 264
 265         @misc_utils.log_exception(_moduleLogger)
 266         def _on_row_changed(self, selection):
 267                 if len(self._programmingModel) == 0:
 268                         return
 269
 270                 # Undo the user's changing of the selection
 271                 self._select_row()
 272
 273         def _select_row(self):
 274                 rowIndex = self._get_current_row()
 275                 if rowIndex < 0:
 276                         return
 277                 path = (rowIndex, )
 278                 if not self._treeView.get_selection().path_is_selected(path):
 279                         self._treeView.get_selection().select_path(path)
 280
 281         def _scroll_to_row(self):
 282                 if self._isDestroyed:
 283                         return
 284                 rowIndex = self._get_current_row()
 285                 if rowIndex < 0:
 286                         return
 287
 288                 path = (rowIndex, )
 289                 self._treeView.scroll_to_cell(path)
 290
 291                 treeViewHeight = self._treeView.get_allocation().height
 292                 viewportHeight = self._viewport.get_allocation().height
 293
 294                 viewsPerPort = treeViewHeight / float(viewportHeight)
 295                 maxRows = len(self._programmingModel)
 296                 percentThrough = rowIndex / float(maxRows)
 297                 dxByIndex = int(viewsPerPort * percentThrough * viewportHeight)
 298
 299                 dxMax = max(treeViewHeight - viewportHeight, 0)
 300
 301                 dx = min(dxByIndex, dxMax)
 302                 adjustment = self._treeScroller.get_vadjustment()
 303                 adjustment.value = dx
 304
 305
 306 gobject.type_register(RadioWindow)