straw/FeedListView.py

   1 """ FeedListView.py
   2
   3 Module for displaying the feeds in the Feeds TreeView.
   4 """
   5 __copyright__ = "Copyright (c) 2002-2005 Free Software Foundation, Inc."
   6 __license__ = """
   7 Straw is free software; you can redistribute it and/or modify it under the
   8 terms of the GNU General Public License as published by the Free Software
   9 Foundation; either version 2 of the License, or (at your option) any later
  10 version.
  11
  12 Straw is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License along with
  17 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  18 Place - Suite 330, Boston, MA 02111-1307, USA. """
  19
  20 from Constants import *
  21 from error import debug
  22 from model import Feed, Item, Category
  23 import Config
  24 import FeedManager
  25 import MVP
  26 import categoryproperties
  27 import feedproperties
  28 import gobject
  29 import gtk
  30 import helpers
  31 import os, copy, locale, logging
  32
  33 class Column:
  34     pixbuf, name, foreground, unread, object, editable = range(6)
  35
  36 _tmp_widget = gtk.Label()
  37
  38 class TreeViewNode(object):
  39     def __init__(self, node, store):
  40         self.node = node
  41         self.store = store
  42
  43         self.node.connect("notify", self._on_unread_count_changed)
  44
  45     def _on_unread_count_changed(self, node, delta):
  46         self.refresh()
  47
  48     def refresh(self):
  49         iter = self.iter
  50
  51         if not iter:
  52             return
  53
  54         self.store.set(iter, Column.pixbuf, self.pixbuf)
  55         self.store.set(iter, Column.unread, self.node.unread_count)
  56         self.store.set(iter, Column.name, self.title)
  57
  58     @property
  59     def title(self):
  60         ''' The title of the node be it a category or a feed '''
  61
  62         if self.node.type == "C":
  63             title = self.node.name
  64         elif self.node.type == "F":
  65             title = self.node.title
  66
  67         if hasattr(self.node, "status") and (self.node.status & FS_UPDATING):
  68             if title:
  69                 title = "<i>" + title + "</i>"
  70
  71         return title
  72
  73     @property
  74     def unread_count(self):
  75         ''' The title of the node be it a category or a feed '''
  76         return self.node.unread_count
  77
  78     @property
  79     def pixbuf(self):
  80         ''' gets the pixbuf to display according to the status of the feed '''
  81         global _tmp_widget
  82
  83         if isinstance(self.node, Feed):
  84             if self.node.status == FS_ERROR:
  85                 return _tmp_widget.render_icon(gtk.STOCK_CANCEL, gtk.ICON_SIZE_MENU)
  86             else:
  87                 return _tmp_widget.render_icon(gtk.STOCK_FILE, gtk.ICON_SIZE_MENU)
  88         else:
  89             return _tmp_widget.render_icon(gtk.STOCK_DIRECTORY, gtk.ICON_SIZE_MENU)
  90
  91     @property
  92     def path_list(self):
  93         path = []
  94         node = copy.copy(self.node)
  95
  96         while node:
  97             path.append(node.norder)
  98             node = copy.copy(node.parent)
  99
 100         path.pop() # We don't need path to "root" category here since it's not in the tree view.
 101         path.reverse()
 102
 103         return path
 104
 105     @property
 106     def path(self):
 107         path = self.path_list
 108
 109         if len(path) == 0:
 110             return None
 111         else:
 112             return ":".join(map(str, path))
 113
 114     @property
 115     def iter(self):
 116         path = self.path
 117
 118         if path == None:
 119             return None
 120         else:
 121             try:
 122                 return self.store.get_iter_from_string(path)
 123             except:
 124                 return None
 125
 126     @property
 127     def parent_path(self):
 128         path = self.path_list
 129         path.pop()
 130
 131         if len(path) == 0:
 132             return None
 133         else:
 134             return ":".join(map(str, path))
 135
 136     @property
 137     def parent_iter(self):
 138         path = self.parent_path
 139
 140         if path == None:
 141             return None
 142         else:
 143             return self.store.get_iter_from_string(path)
 144
 145 class FeedListModel:
 146     ''' The model for the feed list view '''
 147
 148     def __init__(self):
 149         self.refresh_tree()
 150         self._init_signals()
 151
 152     def refresh_tree(self):
 153         self.appmodel = FeedManager.get_model()
 154
 155         self._prepare_store()
 156         self._prepare_model()
 157
 158         self._populate_tree(1, None, [])
 159
 160     def _init_signals(self):
 161         FeedManager._get_instance().connect("feed-added", self._on_node_added)
 162         FeedManager._get_instance().connect("feed-status-changed", self._on_feed_status_changed)
 163         FeedManager._get_instance().connect("category-added", self._on_node_added)
 164
 165     def _prepare_model(self):
 166         self.tv_nodes = dict([(node.id, TreeViewNode(node, self.store)) for node in self.appmodel.values()])
 167
 168     def _prepare_store(self):
 169         self.store = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, gobject.TYPE_PYOBJECT, bool)
 170
 171     def _populate_tree(self, parent_id, parent_iter, done):
 172         for node in self.tv_nodes[parent_id].node.children:
 173             tv_node = self.tv_nodes[node.id]
 174
 175             if node.type == "F":
 176                 self._create_row(tv_node)
 177                 tv_node.store = self.store
 178             elif node.type == "C":
 179                 current_parent = self._create_row(tv_node)
 180                 tv_node.store = self.store
 181
 182                 if self.tv_nodes.has_key(node.id):
 183                     self._populate_tree(node.id, current_parent, done)
 184
 185     def _create_row(self, node, editable = False):
 186         return self.store.append(node.parent_iter, [node.pixbuf,
 187                                               helpers.pango_escape(node.title),
 188                                               'black',
 189                                               node.unread_count,
 190                                               node, editable])
 191
 192     def _on_node_added(self, src, node):
 193         tv_node = TreeViewNode(node, self.store)
 194         self.add_node(tv_node)
 195         self._create_row(tv_node)
 196
 197     def _on_feed_status_changed(self, src, feed):
 198         self.tv_nodes[feed.id].refresh()
 199
 200     def add_node(self, tv_node):
 201         self.tv_nodes[tv_node.node.id] = tv_node
 202
 203     @property
 204     def model(self):
 205         return self.store
 206
 207     def search(self, rows, func, data):
 208         if not rows: return None
 209         for row in rows:
 210             if func(row, data):
 211                 return row
 212             result = self.search(row.iterchildren(), func, data)
 213             if result: return result
 214         return None
 215
 216 class FeedsView(MVP.WidgetView):
 217     def _initialize(self):
 218         self._widget.set_search_column(Column.name)
 219
 220         # pixbuf column
 221         column = gtk.TreeViewColumn()
 222         unread_renderer = gtk.CellRendererText()
 223         column.pack_start(unread_renderer, False)
 224         column.set_attributes(unread_renderer, text = Column.unread)
 225
 226         status_renderer = gtk.CellRendererPixbuf()
 227         column.pack_start(status_renderer, False)
 228         column.set_attributes(status_renderer, pixbuf = Column.pixbuf)
 229
 230         # feed title renderer
 231         title_renderer = gtk.CellRendererText()
 232
 233         title_renderer.connect("edited", self.on_node_edit_title_edited)
 234         title_renderer.connect("editing-canceled", self.on_node_edit_title_canceled)
 235
 236         #title_renderer.set_property('editable', True)
 237         column.pack_start(title_renderer, False)
 238         column.set_attributes(title_renderer,
 239                               foreground=Column.foreground,
 240                               markup=Column.name,
 241                               editable=Column.editable) #, weight=Column.BOLD)
 242
 243         self._widget.append_column(column)
 244
 245         selection = self._widget.get_selection()
 246         selection.set_mode(gtk.SELECTION_MULTIPLE)
 247
 248         self._widget.connect("button_press_event", self._on_button_press_event)
 249         self._widget.connect("popup-menu", self._on_popup_menu)
 250
 251         uifactory = helpers.UIFactory('FeedListActions')
 252         action = uifactory.get_action('/feedlist_popup/refresh')
 253         action.connect('activate', self.on_menu_poll_selected_activate)
 254         action = uifactory.get_action('/feedlist_popup/add_child')
 255         action.connect('activate', self.on_menu_add_child_activate)
 256         action = uifactory.get_action('/feedlist_popup/mark_as_read')
 257         action.connect('activate', self.on_menu_mark_all_as_read_activate)
 258         action = uifactory.get_action('/feedlist_popup/stop_refresh')
 259         action.connect('activate', self.on_menu_stop_poll_selected_activate)
 260         action = uifactory.get_action('/feedlist_popup/remove')
 261         action.connect('activate', self.on_remove_selected_feed)
 262         action = uifactory.get_action('/feedlist_popup/properties')
 263         action.connect('activate', self.on_display_properties_feed)
 264         self.popup = uifactory.get_popup('/feedlist_popup')
 265
 266         treeview = self._widget
 267
 268         treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, [("drop_yes", 0, 0)], gtk.gdk.ACTION_MOVE)
 269         treeview.enable_model_drag_dest([("drop_yes", 0, 0)], gtk.gdk.ACTION_MOVE)
 270         treeview.connect("drag_data_received", self._on_dragdata_received)
 271         treeview.connect("drag_motion", self._on_drag_motion)
 272
 273     def _on_drag_motion(self, treeview, drag_context, x, y, eventtime):
 274         temp = treeview.get_dest_row_at_pos(x, y)
 275
 276         if not temp:
 277             return
 278
 279         model = treeview.get_model()
 280         drop_path, drop_position = temp
 281
 282         # FIXME: Here we use only first selected node of possibly multiple
 283         # selected. See fixme comment in self._on_dragdata_received.
 284         source_node = [tv_node for tv_node in self.selected()][0]
 285
 286         drop_node = model[drop_path][Column.object]
 287         source_path = source_node.path_list
 288
 289         sane_drop_path = self._check_drop_path(model, source_path, drop_path)
 290
 291         is_drop_into = drop_position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE or \
 292             drop_position == gtk.TREE_VIEW_DROP_INTO_OR_AFTER
 293
 294         can_drop_into = drop_node.node.is_parent()
 295
 296         if sane_drop_path and ((is_drop_into and can_drop_into) or not is_drop_into):
 297             treeview.enable_model_drag_dest([("drop_yes", 0, 0)], gtk.gdk.ACTION_MOVE)
 298         else:
 299             treeview.enable_model_drag_dest([("drop_no", 0, 0)], gtk.gdk.ACTION_MOVE)
 300
 301     def _on_dragdata_received(self, treeview, drag_context, x, y, selection, info, eventtime):
 302         model, pathlist = treeview.get_selection().get_selected_rows()
 303
 304         if len(pathlist) > 1:
 305             # FIXME: Maybe we want to support drag and drop for multiple rows?
 306             # For now it's not worth it while there are other things to do.
 307             drag_context.finish(False, False, eventtime)
 308             return
 309
 310         source_path = pathlist[0]
 311         source_iter = model.get_iter(source_path)
 312
 313         temp = treeview.get_dest_row_at_pos(x, y)
 314
 315         if temp != None:
 316             drop_path, drop_pos = temp
 317         else:
 318             drop_path, drop_pos = (len(model) - 1,), gtk.TREE_VIEW_DROP_AFTER
 319
 320         effective_drop_path = self._calculate_effective_drop_path(source_path, drop_path, drop_pos)
 321
 322         if source_path == effective_drop_path:
 323             drag_context.finish(False, False, eventtime)
 324             return
 325
 326         drop_iter = model.get_iter(drop_path)
 327
 328         if not self._check_drop_path(model, source_path, drop_path):
 329             drag_context.finish(False, False, eventtime)
 330             return
 331
 332         node = model[source_path][Column.object].node
 333         self._iter_copy(model, source_iter, drop_iter, drop_pos)
 334
 335         drag_context.finish(True, True, eventtime)
 336         FeedManager.move_node(node, effective_drop_path)
 337
 338     def _check_drop_path(self, model, source_path, drop_path):
 339         """
 340         Verifies if a drop path is not within the subtree of source path so that
 341         we can disallow dropping parent into its own subtree etc. using this check.
 342         """
 343
 344         return list(drop_path[0:len(source_path)]) != list(source_path)
 345
 346     def _iter_copy(self, model, iter_to_copy, target_iter, pos):
 347         """
 348         Recursively copies GTK TreeView iters from source to target using
 349         GTK relative data about drag and drop operation.
 350         """
 351
 352         path = model.get_path(iter_to_copy)
 353
 354         if (pos == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE) or (pos == gtk.TREE_VIEW_DROP_INTO_OR_AFTER):
 355             new_iter = model.prepend(target_iter, model[path])
 356         elif pos == gtk.TREE_VIEW_DROP_BEFORE:
 357             new_iter = model.insert_before(None, target_iter, model[path])
 358         elif pos == gtk.TREE_VIEW_DROP_AFTER:
 359             new_iter = model.insert_after(None, target_iter, model[path])
 360
 361         n = model.iter_n_children(iter_to_copy)
 362
 363         for i in range(n):
 364             next_iter_to_copy = model.iter_nth_child(iter_to_copy, n - i - 1)
 365             self._iter_copy(model, next_iter_to_copy, new_iter, gtk.TREE_VIEW_DROP_INTO_OR_BEFORE)
 366
 367     def _calculate_effective_drop_path(self, source_path, drop_path, drop_pos):
 368         """
 369         Calculate effective absolute drop path given drop_pos and source/destination
 370         of drag and drop operation. GTK uses relative terms for describing drop
 371         destination (after/before/into etc.) while we prefer absolute drop path
 372         and we can take care of reordering ourselves.
 373         """
 374
 375         result = list(drop_path)
 376         same_level = len(source_path) == len(drop_path) and source_path[:-1] == drop_path[:-1]
 377
 378         if drop_pos == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE:
 379             result.append(0)
 380         elif drop_pos == gtk.TREE_VIEW_DROP_INTO_OR_AFTER:
 381             result.append(0)
 382         elif drop_pos == gtk.TREE_VIEW_DROP_BEFORE:
 383             if not same_level or (same_level and source_path[-1] < drop_path[-1]):
 384                 if result[-1] > 0:
 385                     result[-1] -= 1
 386         elif drop_pos == gtk.TREE_VIEW_DROP_AFTER:
 387             if not same_level or (same_level and source_path[-1] > drop_path[-1]):
 388                 result[-1] += 1
 389
 390         return tuple(result)
 391
 392     def _model_set(self):
 393         self._widget.set_model(self._model.model)
 394
 395     def add_selection_changed_listener(self, listener):
 396         selection = self._widget.get_selection()
 397         selection.connect('changed', listener.feedlist_selection_changed, Column.object)
 398
 399     def _on_popup_menu(self, treeview, *args):
 400         self.popup.popup(None, None, None, 0, 0)
 401
 402     def _on_button_press_event(self, treeview, event):
 403         retval = 0
 404
 405         if event.button == 3:
 406             x = int(event.x)
 407             y = int(event.y)
 408             time = gtk.get_current_event_time()
 409             path = treeview.get_path_at_pos(x, y)
 410
 411             if path is None:
 412                 return 1
 413
 414             path = path[0]
 415             self.node_at_popup = self.model.store[path][Column.object]
 416             treeview.grab_focus()
 417
 418             if self.selected_count() < 2:
 419                 selection = treeview.get_selection()
 420                 selection.unselect_all()
 421                 selection.select_path(path)
 422
 423             self.popup.popup(None, None, None, event.button, time)
 424             retval = 1
 425
 426         return retval
 427
 428     def get_selected_node(self):
 429         nodes = [node for node in self.selected()]
 430
 431         if len(nodes) > 0:
 432             return nodes[0].node
 433         else:
 434             return None
 435
 436     def get_expanded_nodes(self):
 437         expanded = []
 438
 439         def add(treeview, path, expanded):
 440             node = treeview.get_model()[path][Column.object].node
 441             expanded.append(node)
 442
 443         self._widget.map_expanded_rows(add, expanded)
 444
 445         return expanded
 446
 447     def expand_nodes(self, nodes):
 448         for node_id in nodes:
 449             if node_id in self.model.tv_nodes:
 450                 path = self.model.tv_nodes[node_id].path
 451                 self._widget.expand_row(path, False)
 452
 453     def select_node(self, id):
 454         path = self.model.tv_nodes[id].path
 455
 456         if not path:
 457             return
 458
 459         selection = self._widget.get_selection()
 460         selection.unselect_all()
 461         self._widget.expand_to_path(path)
 462         selection.select_path(path)
 463         self._widget.grab_focus()
 464
 465     def selected_count(self):
 466         selection = self._widget.get_selection()
 467         pathlist = selection.get_selected_rows()[1]
 468         return len(pathlist)
 469
 470     def selected(self):
 471         selection = self._widget.get_selection()
 472         (model, pathlist) = selection.get_selected_rows()
 473         nodes = [model[path][Column.object] for path in pathlist]
 474
 475         for tv_node in nodes:
 476             yield tv_node
 477
 478     def foreach_selected(self, func):
 479         selection = self._widget.get_selection()
 480         (model, pathlist) = selection.get_selected_rows()
 481         iters = [model.get_iter(path) for path in pathlist]
 482         try:
 483             for treeiter in iters:
 484                 object = model.get_value(treeiter, Column.object)
 485                 func(object, model, treeiter)
 486         except TypeError, te:
 487             logging.exception(te)
 488
 489     def on_menu_add_child_activate(self, *args):
 490         node = self.node_at_popup.node
 491
 492         if not self.node_at_popup.node.is_parent():
 493             node = node.parent
 494
 495         self.begin_add_category(node)
 496
 497     def begin_add_category(self, node):
 498         category = Category()
 499         category.parent = node
 500         category.norder = len(node.children)
 501         self.new_child = TreeViewNode(category, self.model.store)
 502         iter = self.model._create_row(self.new_child, editable = True)
 503         path = self.model.store.get_path(iter)
 504         column = self._widget.get_column(0)
 505
 506         parent_path = self.new_child.parent_path
 507
 508         if parent_path:
 509             self._widget.expand_row(parent_path, False)
 510
 511         self._widget.set_cursor_on_cell(path, focus_column = column, start_editing = True)
 512
 513     def on_menu_poll_selected_activate(self, *args):
 514         """config = Config.get_instance()
 515
 516         if config.offline: #XXX
 517             config.offline = not config.offline"""
 518
 519         FeedManager.update_nodes([node.node for node in self.selected()])
 520
 521     def on_menu_stop_poll_selected_activate(self, *args):
 522         self.foreach_selected(lambda o,*args: o.feed.router.stop_polling())
 523
 524     def on_menu_mark_all_as_read_activate(self, *args):
 525         self.foreach_selected(lambda o,*args: o.feed.mark_items_as_read())
 526
 527     def on_remove_selected_feed(self, *args):
 528         nodes = [tv_node for tv_node in self.selected()]
 529
 530         FeedManager.delete_nodes([tv_node.node.id for tv_node in nodes])
 531
 532         for node in nodes:
 533             iter = node.iter
 534
 535             if iter:
 536                 self.model.store.remove(iter)
 537
 538     def on_node_edit_title_canceled(self, cellrenderer):
 539         if self.new_child:
 540             debug("on_node_edit_title_canceled (new_child), removing %s" % str(self.new_child.path))
 541             self.model.store.remove(self.new_child.iter)
 542             self.new_child = None
 543
 544     def on_node_edit_title_edited(self, cellrenderertext, path, new_text):
 545         if len(new_text) > 0:
 546             self.new_child.node.name = new_text
 547             FeedManager.save_category(self.new_child.node)
 548
 549         self.model.store.remove(self.new_child.iter)
 550         self.new_child = None
 551
 552     def on_display_properties_feed(self, *args):
 553         selected_tv_node = [tv_node for tv_node in self.selected()][0]
 554         self._presenter.show_feed_information(selected_tv_node.node)
 555
 556     def add_category(self):
 557         self.begin_add_category(self._model.tv_nodes[1].node)
 558
 559     def select_first_feed(self):
 560         selection = self._widget.get_selection()
 561         (model, pathlist) = selection.get_selected_rows()
 562         treeiter = model.get_iter_first()
 563         if not treeiter or not model.iter_is_valid(treeiter):
 564             return False
 565         self.set_cursor(treeiter)
 566         return True
 567
 568     def select_next_feed(self, with_unread=False):
 569         ''' Scrolls to the next feed in the feed list
 570
 571         If there is no selection, selects the first feed. If multiple feeds
 572         are selected, selects the feed after the last selected feed.
 573
 574         If unread is True, selects the next unread with unread items.
 575
 576         If the selection next-to-be is a category, go to the iter its first
 577         child. If current selection is a child, then go to (parent + 1),
 578         provided that (parent + 1) is not a category.
 579         '''
 580         has_unread = False
 581         def next(model, current):
 582             treeiter = model.iter_next(current)
 583             if not treeiter: return False
 584             if model.iter_depth(current): next(model, model.iter_parent(current))
 585             path = model.get_path(treeiter)
 586             if with_unread and model[path][Column.unread] < 1:
 587                 next(model, current)
 588             self.set_cursor(treeiter)
 589             return True
 590         selection = self._widget.get_selection()
 591         (model, pathlist) = selection.get_selected_rows()
 592         iters = [model.get_iter(path) for path in pathlist]
 593         try:
 594             current = iters.pop()
 595             if model.iter_has_child(current):
 596                 iterchild = model.iter_children(current)
 597                 # make the row visible
 598                 path = model.get_path(iterchild)
 599                 for i in range(len(path)):
 600                     self._widget.expand_row(path[:i+1], False)
 601                 # select his first born child
 602                 if with_unread and model[path][Column.unread] > 0:
 603                     self.set_cursor(iterchild)
 604                     has_unread = True
 605                 else:
 606                     has_unread = next(model, current)
 607             has_unread = next(model,current)
 608         except IndexError:
 609             self.set_cursor(model.get_iter_first())
 610             has_unread = True
 611         return has_unread
 612
 613     def select_previous_feed(self):
 614         ''' Scrolls to the previous feed in the feed list.
 615
 616         If there is no selection, selects the first feed. If there's multiple
 617         selection, selects the feed before the first selected feed.
 618
 619         If the previous selection is a category, select the last node in that
 620         category. If the current selection is a child, then go to (parent -
 621         1). If parent is the first feed, wrap and select the last feed or
 622         category in the list.
 623         '''
 624         def previous(model, current):
 625             path = model.get_path(current)
 626             treerow = model[path[-1]-1]
 627             self.set_cursor(treerow.iter)
 628         selection = self._widget.get_selection()
 629         (model, pathlist) = selection.get_selected_rows()
 630         iters = [model.get_iter(path) for path in pathlist]
 631         try:
 632             current_first = iters.pop(0)
 633             if model.iter_has_child(current_first):
 634                 children = model.iter_n_children(current_first)
 635                 treeiter = model.iter_nth_child(children - 1)
 636                 self.set_cursor(treeiter)
 637                 return
 638             previous(model, current_first)
 639         except IndexError:
 640             self.set_cursor(model.get_iter_first())
 641         return
 642
 643     def set_cursor(self, treeiter, col_id=None, edit=False):
 644         if not treeiter:
 645             return
 646
 647         column = None
 648         path = self._model.model.get_path(treeiter)
 649
 650         if col_id:
 651             column = self._widget.get_column(col_id)
 652
 653         self._widget.set_cursor(path, column, edit)
 654         self._widget.scroll_to_cell(path, column)
 655         self._widget.grab_focus()
 656
 657 class FeedsPresenter(MVP.BasicPresenter):
 658     def _initialize(self):
 659         self.model = FeedListModel()
 660
 661     def store_state(self):
 662         node = self.view.get_selected_node()
 663         id = -1
 664
 665         if node:
 666             id = node.id
 667
 668         Config.set(OPTION_LAST_SELECTED_NODE, id)
 669         Config.set(OPTION_LAST_EXPANDED_NODES, ",".join([str(node.id) for node in self.view.get_expanded_nodes()]))
 670
 671     def restore_state(self):
 672         id = Config.get(OPTION_LAST_SELECTED_NODE)
 673
 674         if id != -1:
 675             self.view.select_node(id)
 676
 677         expanded = Config.get(OPTION_LAST_EXPANDED_NODES)
 678
 679         if expanded:
 680             try:
 681                 expanded = map(int, expanded.split(","))
 682             except ValueError:
 683                 expanded = []
 684
 685         self.view.expand_nodes(expanded)
 686
 687     def add_category(self):
 688         self.view.add_category()
 689
 690     def select_first_feed(self):
 691         return self.view.select_first_feed()
 692
 693     def select_next_feed(self, with_unread=False):
 694         return self.view.select_next_feed(with_unread)
 695
 696     def select_previous_feed(self):
 697         return self.view.select_previous_feed()
 698
 699     def show_feed_information(self, node):
 700         if node.type == "C":
 701             properties = categoryproperties
 702         elif node.type == "F":
 703             properties = feedproperties
 704
 705         properties.show(node)