src/lib/ItemList.py

   1 """ ItemList.py
   2
   3 Handles listing of feed items in a view (i.e. GTK+ TreeView)
   4 """
   5 __copyright__ = "Copyright (c) 2002-2005 Free Software Foundation, Inc."
   6 __license__ = """GNU General Public License
   7
   8 This program is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU General Public License as
  10 published by the Free Software Foundation; either version 2 of the
  11 License, or (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public
  19 License along with this program; if not, write to the
  20 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.
  22 """
  23
  24 from xml.sax import saxutils
  25 import pygtk
  26 pygtk.require('2.0')
  27 import gobject
  28 import gtk
  29 import pango
  30 import Event
  31 import MVP
  32 import error
  33 import utils
  34
  35 class Column:
  36     """
  37     Constants for the item list treeview columns
  38     """
  39     TITLE = 0
  40     STICKY = 1
  41     ITEM = 2
  42     WEIGHT = 3
  43     STICKY_FLAG = 4
  44     FOREGROUND = 5
  45
  46 class ItemsView(MVP.WidgetView):
  47     ui = """
  48     <ui>
  49         <popup name=\"itemlist_popup\">
  50             <menuitem action=\"mark_as_unread\"/>
  51         </popup>
  52     </ui>
  53     """
  54
  55     def _initialize(self):
  56         self._widget.connect("button_press_event",self._on_button_press_event)
  57         self._widget.connect("popup-menu", self._on_popup_menu)
  58         self._widget.connect("row-activated", self._on_row_activated)
  59         self._popup = None
  60
  61
  62     def scroll_to_cell(self, path):
  63         selection = self._widget.get_selection()
  64         selection.select_path(path)
  65         self._widget.scroll_to_cell(path)
  66         self._widget.set_cursor(path)
  67         return
  68
  69     def get_widget_selection(self):
  70         return self._widget.get_selection()
  71
  72     def _create_popup(self):
  73         actions = [
  74             ("mark_as_unread", gtk.STOCK_CONVERT, "Mark as _Unread", None,
  75              "Mark this item as unread", self._on_menu_mark_as_unread_activate)
  76             ]
  77         self._uimanager = gtk.UIManager()
  78         actiongroup = gtk.ActionGroup("ItemListActions")
  79         actiongroup.add_actions(actions)
  80         self._uimanager.insert_action_group(actiongroup, 0)
  81         self._uimanager.add_ui_from_string(self.ui)
  82         self._popup = self._uimanager.get_widget('/itemlist_popup')
  83
  84     def _on_popup_menu(self, treeview, *args):
  85         self._popup.popup(None,None,None,0,0)
  86
  87     def _on_button_press_event(self, treeview, event):
  88         val = 0
  89         if event.button == 3:
  90             x = int(event.x)
  91             y = int(event.y)
  92             time = gtk.get_current_event_time()
  93             path = treeview.get_path_at_pos(x, y)
  94             if path is None:
  95                 return 1
  96             path, col, cellx, celly = path
  97             treeview.grab_focus()
  98             treeview.set_cursor( path, col, 0)
  99             self._popup.popup(None, None, None, event.button, time)
 100             val = 1
 101         return val
 102
 103     def _on_menu_mark_as_unread_activate(self, *args):
 104         self._presenter.mark_selected_item_as_unread()
 105
 106     def _item_selection_changed(self, selection):
 107         selected = selection.get_selected()
 108         if selected:
 109             self._presenter.selection_changed(selected)
 110         return
 111
 112     def _on_row_activated(self, treeview, path, column):
 113         model = self._widget.get_model()
 114         try: treeiter = model.get_iter(path)
 115         except ValueError:
 116             return
 117         link = model.get_value(treeiter, Column.ITEM).link
 118         if link:
 119             utils.url_show(link)
 120         return
 121
 122 class ItemListView(ItemsView):
 123     """
 124     Widget: gtk.Treeview
 125     Model: ListStore
 126     Presenter: ItemListPresenter
 127     """
 128     def _initialize(self):
 129         ItemsView._initialize(self)
 130         self._widget.set_rules_hint(False)
 131         self._create_popup()
 132         selection = self._widget.get_selection()
 133         selection.connect("changed", self._item_selection_changed)
 134
 135     def _model_set(self):
 136         self._widget.set_model(self._model)
 137         self._create_columns()
 138
 139     def _sticky_toggled(self, cell, path):
 140         self._presenter.sticky_toggled(cell, path,
 141                                        Column.ITEM, Column.STICKY_FLAG)
 142         return
 143
 144     def _create_columns(self):
 145         renderer = gtk.CellRendererToggle()
 146         column = gtk.TreeViewColumn(_('Keep'), renderer,
 147                                     active=Column.STICKY_FLAG)
 148         column.set_resizable(True)
 149         column.set_reorderable(True)
 150         self._widget.append_column(column)
 151         renderer.connect('toggled', self._sticky_toggled)
 152
 153         renderer = gtk.CellRendererText()
 154         column = gtk.TreeViewColumn(_('_Title'), renderer,
 155                                     text=Column.TITLE,
 156                                     foreground=Column.FOREGROUND,
 157                                     weight=Column.WEIGHT)
 158         column.set_resizable(True)
 159         column.set_reorderable(True)
 160         self._widget.append_column(column)
 161         return
 162
 163 class ItemsPresenter(MVP.BasicPresenter):
 164     def _connect(self):
 165         self.initialize_slots(Event.ItemSelectionChangedSignal)
 166         self._selected_item = None
 167         return
 168
 169     def selection_changed(self, selected):
 170         model, treeiter = selected
 171         if not treeiter: return
 172         assert model is self._model
 173         path = model.get_path(treeiter)
 174         self._item_selected(path)
 175         self._view.scroll_to_cell(path)
 176
 177     def _item_selected(self, path):
 178         item = self._model[path][Column.ITEM]
 179         if self._selected_item is not item:
 180             self._selected_item = item
 181             if not self._selected_item.seen:
 182                 self._selected_item.seen = 1
 183             self.emit_signal(Event.ItemSelectionChangedSignal(self,self._selected_item))
 184         return
 185
 186     def mark_selected_item_as_unread(self):
 187         self._selected_item.seen = 0
 188         self._mark_item(self._selected_item)
 189
 190     def display_empty_feed(self):
 191         self._model.clear()
 192         return
 193
 194     def _set_column_weight(self, item, path):
 195         tree_iter = self._model.get_iter(path)
 196         weight = (pango.WEIGHT_BOLD, pango.WEIGHT_NORMAL)[item.seen]
 197         colour = ("#0000FF", "#000000")[item.seen]
 198         self._model.set_value(tree_iter, Column.FOREGROUND, colour)
 199         self._model.set_value(tree_iter, Column.WEIGHT, weight)
 200         return
 201
 202     def _mark_item(self, item, index=None):
 203         """
 204         Marks an item as 'READ'
 205
 206         Subclass SHOULD implement this
 207         """
 208         raise NotImplemented
 209
 210 class ItemListPresenter(ItemsPresenter):
 211     def _initialize(self):
 212         model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_OBJECT,
 213                               gobject.TYPE_PYOBJECT, gobject.TYPE_INT,
 214                               gobject.TYPE_BOOLEAN, gobject.TYPE_STRING)
 215         self.model = model
 216         self._connect()
 217         self._selected_feed = None
 218         selection = self._view.get_widget_selection()
 219         selection.set_mode(gtk.SELECTION_SINGLE)
 220
 221     def feedlist_selection_changed(self, feedlist_selection, feedlist_model):
 222         (model, pathlist) = feedlist_selection.get_selected_rows()
 223         ## XXX fix this, get and display the union of feeds
 224         feeds = feedlist_model.get_feeds(pathlist)
 225         if feeds:
 226             self.display_feed_items(feeds[0])
 227         print "feed list selection chaanged in item list ", feeds
 228
 229     def select_previous_item(self):
 230         """
 231         Selects the item before the current selection. If there
 232         is no current selection, selects the last item. If there is no
 233         previous row, returns False.
 234         """
 235         selection = self._view.get_widget_selection()
 236         model, treeiter = selection.get_selected()
 237         # select the first item if there is no selection
 238         if not treeiter:
 239             treeiter = model.get_iter_first()
 240         path = self._model.get_path(treeiter)
 241         # check if there's an item
 242         if not path:
 243             return False
 244         prev_path = path[-1]-1
 245         # we don't cycle through the items so return False if there are no
 246         # more items to go to
 247         if prev_path < 0:
 248             return False
 249         selection.select_path(path[-1]-1,)
 250         return True
 251
 252     def select_next_item(self):
 253         """
 254         Selects the item after the current selection. If there is no current
 255         selection, selects the first item. If there is no next row, returns False.
 256         """
 257         selection = self._view.get_widget_selection()
 258         model, treeiter = selection.get_selected()
 259         if not treeiter:
 260             treeiter = model.get_iter_first()
 261         next_iter = model.iter_next(treeiter)
 262         if not next_iter or not self._model.iter_is_valid(treeiter):
 263             return False
 264         next_path = model.get_path(next_iter)
 265         selection.select_path(next_path)
 266         return True
 267
 268     def select_last_item(self):
 269         """
 270         Selects the last item in this list.
 271         """
 272         selection = self._view.get_widget_selection()
 273         selection.select_path(len(self._model) - 1)
 274         return True
 275
 276     def select_next_unread_item(self):
 277         """
 278         Selects the first unread item after the current selection. If there is
 279         no current selection, or if there are no unread items, returns False..
 280
 281         By returning False, the caller can either go to the next feed, or go
 282         to the next feed with an unread item.
 283         """
 284         has_unread = False
 285         selection = self._view.get_widget_selection()
 286         selected_row = selection.get_selected()
 287         # check if we have a selection. if none,
 288         # start searching from the first item
 289         if not selected_row[1]:
 290             treerow = self._model[0]
 291         else:
 292             model, treeiter = selected_row
 293             if not treeiter:
 294                 return has_unread
 295             nextiter = model.iter_next(treeiter)
 296             if not nextiter: # no more rows to iterate
 297                 return has_unread
 298             treerow = self._model[model.get_path(nextiter)]
 299         while(treerow):
 300             item = treerow[Column.ITEM]
 301             if not item.seen:
 302                 has_unread = True
 303                 selection.select_path(treerow.path)
 304                 break
 305             treerow = treerow.next
 306         return has_unread
 307
 308
 309     def sticky_toggled(self, cell, path, item_column, stickyflag_column):
 310         treeiter = self._model.get_iter((int(path),))
 311         item = self._model.get_value(treeiter, item_column)
 312         item.sticky = not item.sticky
 313         self._model.set(treeiter, stickyflag_column, item.sticky)
 314
 315     def display_feed_items(self, feed, select_first=1):
 316         redisplay = self._selected_feed is feed
 317         if self._selected_feed and not redisplay:
 318             self._selected_feed.signal_disconnect(Event.RefreshFeedDisplaySignal,
 319                                          self._feed_order_changed)
 320             self._selected_feed.signal_disconnect(Event.AllItemsReadSignal,
 321                                          self._all_items_read)
 322             self._selected_feed.signal_disconnect(Event.ItemReadSignal,
 323                                          self._item_read)
 324         self._selected_feed = feed
 325         if not redisplay:
 326             self._selected_feed.signal_connect(Event.RefreshFeedDisplaySignal,
 327                                 self._feed_order_changed)
 328             self._selected_feed.signal_connect(Event.AllItemsReadSignal,
 329                                 self._all_items_read)
 330             self._selected_feed.signal_connect(Event.ItemReadSignal,
 331                                 self._item_read)
 332         count = self._render_feed(self._selected_feed)
 333         if not redisplay and count:
 334             if not self.select_next_unread_item():
 335                 selection = self._view.get_widget_selection()
 336                 selection.select_path((0,))
 337         return
 338
 339     def _feed_order_changed(self, event):
 340         if event.sender is self._selected_feed:
 341             item = None
 342             selection = self._view.get_widget_selection()
 343             model, treeiter = selection.get_selected()
 344             if treeiter is not None:
 345                 path = model.get_path(treeiter)
 346                 item = model[path[0]][Column.ITEM]
 347             self._render_feed(event.sender)
 348             if item:
 349                 path = (item.feed.get_item_index(item),)
 350             else:
 351                 path = (0,) # first item
 352             selection.select_path(path)
 353
 354     def _all_items_read(self, signal):
 355         for index, item in signal.changed:
 356             self._mark_item(item, index)
 357
 358     def _item_read(self, signal):
 359         self._mark_item(signal.item)
 360
 361     def _render_feed(self, feed):
 362         self._model.clear()
 363         curr_iter = None
 364         for item in feed.items:
 365             weight = (pango.WEIGHT_BOLD, pango.WEIGHT_NORMAL)[item.seen]
 366             colour = ("#0000FF", "#000000")[item.seen]
 367             treeiter = self._model.append()
 368             self._model.set(treeiter,
 369                             Column.TITLE, item.title,
 370                             Column.ITEM, item,
 371                             Column.WEIGHT, weight,
 372                             Column.STICKY_FLAG, item.sticky,
 373                             Column.FOREGROUND, colour)
 374             if item is self._selected_item:
 375                 curr_iter = treeiter
 376
 377         if curr_iter:
 378             path = self._model.get_path(curr_iter)
 379             self._view.scroll_to_cell(path)
 380         return len(feed.items)
 381
 382     def _mark_item(self, item, path=None):
 383         if path is None:
 384             path = (item.feed.get_item_index(item),)
 385         self._set_column_weight(item, path)
 386         return