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         if not id in self.model.tv_nodes:
 455             return
 456
 457         path = self.model.tv_nodes[id].path
 458
 459         if not path:
 460             return
 461
 462         selection = self._widget.get_selection()
 463         selection.unselect_all()
 464         self._widget.expand_to_path(path)
 465         selection.select_path(path)
 466         self._widget.grab_focus()
 467
 468     def selected_count(self):
 469         selection = self._widget.get_selection()
 470         pathlist = selection.get_selected_rows()[1]
 471         return len(pathlist)
 472
 473     def selected(self):
 474         selection = self._widget.get_selection()
 475         (model, pathlist) = selection.get_selected_rows()
 476         nodes = [model[path][Column.object] for path in pathlist]
 477
 478         for tv_node in nodes:
 479             yield tv_node
 480
 481     def foreach_selected(self, func):
 482         selection = self._widget.get_selection()
 483         (model, pathlist) = selection.get_selected_rows()
 484         iters = [model.get_iter(path) for path in pathlist]
 485         try:
 486             for treeiter in iters:
 487                 object = model.get_value(treeiter, Column.object)
 488                 func(object, model, treeiter)
 489         except TypeError, te:
 490             logging.exception(te)
 491
 492     def on_menu_add_child_activate(self, *args):
 493         node = self.node_at_popup.node
 494
 495         if not self.node_at_popup.node.is_parent():
 496             node = node.parent
 497
 498         self.begin_add_category(node)
 499
 500     def begin_add_category(self, node):
 501         category = Category()
 502         category.parent = node
 503         category.norder = len(node.children)
 504         self.new_child = TreeViewNode(category, self.model.store)
 505         iter = self.model._create_row(self.new_child, editable = True)
 506         path = self.model.store.get_path(iter)
 507         column = self._widget.get_column(0)
 508
 509         parent_path = self.new_child.parent_path
 510
 511         if parent_path:
 512             self._widget.expand_row(parent_path, False)
 513
 514         self._widget.set_cursor_on_cell(path, focus_column = column, start_editing = True)
 515
 516     def on_menu_poll_selected_activate(self, *args):
 517         """config = Config.get_instance()
 518
 519         if config.offline: #XXX
 520             config.offline = not config.offline"""
 521
 522         FeedManager.update_nodes([node.node for node in self.selected()])
 523
 524     def on_menu_stop_poll_selected_activate(self, *args):
 525         self.foreach_selected(lambda o,*args: o.feed.router.stop_polling())
 526
 527     def on_menu_mark_all_as_read_activate(self, *args):
 528         self.foreach_selected(lambda o,*args: o.feed.mark_items_as_read())
 529
 530     def on_remove_selected_feed(self, *args):
 531         nodes = [tv_node for tv_node in self.selected()]
 532
 533         FeedManager.delete_nodes([tv_node.node.id for tv_node in nodes])
 534
 535         for node in nodes:
 536             iter = node.iter
 537
 538             if iter:
 539                 self.model.store.remove(iter)
 540
 541     def on_node_edit_title_canceled(self, cellrenderer):
 542         if self.new_child:
 543             debug("on_node_edit_title_canceled (new_child), removing %s" % str(self.new_child.path))
 544             self.model.store.remove(self.new_child.iter)
 545             self.new_child = None
 546
 547     def on_node_edit_title_edited(self, cellrenderertext, path, new_text):
 548         if len(new_text) > 0:
 549             self.new_child.node.name = new_text
 550             FeedManager.save_category(self.new_child.node)
 551
 552         self.model.store.remove(self.new_child.iter)
 553         self.new_child = None
 554
 555     def on_display_properties_feed(self, *args):
 556         selected_tv_node = [tv_node for tv_node in self.selected()][0]
 557         self._presenter.show_feed_information(selected_tv_node.node)
 558
 559     def add_category(self):
 560         self.begin_add_category(self._model.tv_nodes[1].node)
 561
 562     def select_first_feed(self):
 563         selection = self._widget.get_selection()
 564         (model, pathlist) = selection.get_selected_rows()
 565         treeiter = model.get_iter_first()
 566         if not treeiter or not model.iter_is_valid(treeiter):
 567             return False
 568         self.set_cursor(treeiter)
 569         return True
 570
 571     def select_next_feed(self, with_unread=False):
 572         ''' Scrolls to the next feed in the feed list
 573
 574         If there is no selection, selects the first feed. If multiple feeds
 575         are selected, selects the feed after the last selected feed.
 576
 577         If unread is True, selects the next unread with unread items.
 578
 579         If the selection next-to-be is a category, go to the iter its first
 580         child. If current selection is a child, then go to (parent + 1),
 581         provided that (parent + 1) is not a category.
 582         '''
 583         has_unread = False
 584         def next(model, current):
 585             treeiter = model.iter_next(current)
 586             if not treeiter: return False
 587             if model.iter_depth(current): next(model, model.iter_parent(current))
 588             path = model.get_path(treeiter)
 589             if with_unread and model[path][Column.unread] < 1:
 590                 next(model, current)
 591             self.set_cursor(treeiter)
 592             return True
 593         selection = self._widget.get_selection()
 594         (model, pathlist) = selection.get_selected_rows()
 595         iters = [model.get_iter(path) for path in pathlist]
 596         try:
 597             current = iters.pop()
 598             if model.iter_has_child(current):
 599                 iterchild = model.iter_children(current)
 600                 # make the row visible
 601                 path = model.get_path(iterchild)
 602                 for i in range(len(path)):
 603                     self._widget.expand_row(path[:i+1], False)
 604                 # select his first born child
 605                 if with_unread and model[path][Column.unread] > 0:
 606                     self.set_cursor(iterchild)
 607                     has_unread = True
 608                 else:
 609                     has_unread = next(model, current)
 610             has_unread = next(model,current)
 611         except IndexError:
 612             self.set_cursor(model.get_iter_first())
 613             has_unread = True
 614         return has_unread
 615
 616     def select_previous_feed(self):
 617         ''' Scrolls to the previous feed in the feed list.
 618
 619         If there is no selection, selects the first feed. If there's multiple
 620         selection, selects the feed before the first selected feed.
 621
 622         If the previous selection is a category, select the last node in that
 623         category. If the current selection is a child, then go to (parent -
 624         1). If parent is the first feed, wrap and select the last feed or
 625         category in the list.
 626         '''
 627         def previous(model, current):
 628             path = model.get_path(current)
 629             treerow = model[path[-1]-1]
 630             self.set_cursor(treerow.iter)
 631         selection = self._widget.get_selection()
 632         (model, pathlist) = selection.get_selected_rows()
 633         iters = [model.get_iter(path) for path in pathlist]
 634         try:
 635             current_first = iters.pop(0)
 636             if model.iter_has_child(current_first):
 637                 children = model.iter_n_children(current_first)
 638                 treeiter = model.iter_nth_child(children - 1)
 639                 self.set_cursor(treeiter)
 640                 return
 641             previous(model, current_first)
 642         except IndexError:
 643             self.set_cursor(model.get_iter_first())
 644         return
 645
 646     def set_cursor(self, treeiter, col_id=None, edit=False):
 647         if not treeiter:
 648             return
 649
 650         column = None
 651         path = self._model.model.get_path(treeiter)
 652
 653         if col_id:
 654             column = self._widget.get_column(col_id)
 655
 656         self._widget.set_cursor(path, column, edit)
 657         self._widget.scroll_to_cell(path, column)
 658         self._widget.grab_focus()
 659
 660 class FeedsPresenter(MVP.BasicPresenter):
 661     def _initialize(self):
 662         self.model = FeedListModel()
 663
 664     def store_state(self):
 665         node = self.view.get_selected_node()
 666         id = -1
 667
 668         if node:
 669             id = node.id
 670
 671         Config.set(OPTION_LAST_SELECTED_NODE, id)
 672         Config.set(OPTION_LAST_EXPANDED_NODES, ",".join([str(node.id) for node in self.view.get_expanded_nodes()]))
 673
 674     def restore_state(self):
 675         id = Config.get(OPTION_LAST_SELECTED_NODE)
 676
 677         if id != -1:
 678             self.view.select_node(id)
 679
 680         expanded = Config.get(OPTION_LAST_EXPANDED_NODES)
 681
 682         if expanded:
 683             try:
 684                 expanded = map(int, expanded.split(","))
 685             except ValueError:
 686                 expanded = []
 687
 688         self.view.expand_nodes(expanded)
 689
 690     def add_category(self):
 691         self.view.add_category()
 692
 693     def select_first_feed(self):
 694         return self.view.select_first_feed()
 695
 696     def select_next_feed(self, with_unread=False):
 697         return self.view.select_next_feed(with_unread)
 698
 699     def select_previous_feed(self):
 700         return self.view.select_previous_feed()
 701
 702     def show_feed_information(self, node):
 703         if node.type == "C":
 704             properties = categoryproperties
 705         elif node.type == "F":
 706             properties = feedproperties
 707
 708         properties.show(node)