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