straw/Application.py

   1 """ Application.py
   2
   3 This is the main module that binds everything together.
   4
   5 """
   6
   7 __copyright__ = "Copyright (c) 2002-2005 Free Software Foundation, Inc."
   8 __license__ = """ GNU General Public License
   9
  10 This program is free software; you can redistribute it and/or modify it under the
  11 terms of the GNU General Public License as published by the Free Software
  12 Foundation; either version 2 of the License, or (at your option) any later
  13 version.
  14
  15 This program is distributed in the hope that it will be useful, but WITHOUT
  16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License along with
  20 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  21 Place - Suite 330, Boston, MA 02111-1307, USA. """
  22
  23 from Constants import *
  24 from FeedListView import FeedsView, FeedsPresenter
  25 from ItemList import ItemListPresenter, ItemListView
  26 from ItemView import ItemView
  27 from MainloopManager import MainloopManager
  28 from MessageManager import post_status_message, get_status_manager, start_services
  29 from OfflineToggle import OfflineToggle
  30 from subscribe import subscribe_show
  31 from xml.sax import saxutils
  32 import Config
  33 import FeedManager
  34 import ItemManager
  35 import JobManager
  36 import MVP
  37 import error
  38 import feedproperties
  39 import gnome, gconf
  40 import gobject, gtk, gtk.glade
  41 import helpers
  42 import os, gettext, getopt, sys
  43 import preferences
  44 import pygtk
  45 import straw.defs
  46 import time
  47 pygtk.require('2.0')
  48
  49 log = error.get_logger()
  50
  51 class StatusPresenter(MVP.BasicPresenter):
  52     def _initialize(self):
  53         self._mmgr = get_status_manager()
  54         self._mmgr.connect('changed', self._display)
  55
  56     def _display(self, *args):
  57         cid =  self._view.get_context_id("straw_main")
  58         self._view.pop(cid)
  59         self._view.push(cid, self._mmgr.read_message())
  60         return
  61
  62 class ErrorPresenter:
  63     def __init__(self, widget):
  64         self._widget = widget
  65         self._tooltips = gtk.Tooltips()
  66         self._text = ''
  67         #self._curr_feed = None
  68         #self._curr_category = None
  69         #fclist = FeedCategoryList.get_instance()
  70         #fclist.connect('category-changed', self._category_changed)
  71
  72     def feedlist_selection_changed(self, selection, column):
  73         errortexts = None
  74         return
  75         (model, pathlist) = selection.get_selected_rows()
  76         iters = [model.get_iter(path) for path in pathlist]
  77         if not iters: return
  78         errorfeeds = []
  79         nodes = [model.get_value(treeiter, column) for treeiter in iters]
  80         try:
  81             errorfeeds = [node.feed for node in nodes if node.feed and node.feed.error]
  82             errortexts = [feed.error for feed in errorfeeds]
  83         except TypeError, te:
  84             print te
  85             ### XXX display OPML Category error too
  86
  87         text = list()
  88         if errorfeeds:
  89             text.append(_("Error:"))
  90             text += errortexts
  91
  92         if text:
  93             t = "\n".join(text)
  94             self._tooltips.set_tip(self._widget, t, t)
  95             self._tooltips.enable()
  96             self._widget.show()
  97         else:
  98             self._tooltips.disable()
  99             self._widget.hide()
 100         return
 101
 102     def hide(self):
 103         self._widget.hide()
 104
 105 class ToolbarView(MVP.WidgetView):
 106     """ Widget: gtk.Toolbar"""
 107     GCONF_DESKTOP_INTERFACE = "/desktop/gnome/interface"
 108
 109     def _initialize(self):
 110         client = gconf.client_get_default()
 111         if not client.dir_exists(self.GCONF_DESKTOP_INTERFACE):
 112             return
 113         client.add_dir(self.GCONF_DESKTOP_INTERFACE,
 114                        gconf.CLIENT_PRELOAD_NONE)
 115         client.notify_add(self.GCONF_DESKTOP_INTERFACE+"/toolbar_style",
 116                           self._toolbar_style_changed)
 117         self._widget.set_tooltips(True)
 118
 119     def _toolbar_style_changed(self, client, notify_id, entry, *args):
 120         value = entry.value.get_string()
 121         self._presenter.style_changed(value)
 122
 123     def set_style(self, style):
 124         self._widget.set_style(style)
 125
 126     def get_style(self):
 127         client = gconf.client_get_default()
 128         current_style = client.get_string(self.GCONF_DESKTOP_INTERFACE+"/toolbar_style")
 129         return current_style
 130
 131 class ToolbarPresenter(MVP.BasicPresenter):
 132     STYLES = {'both':gtk.TOOLBAR_BOTH,
 133               'text':gtk.TOOLBAR_TEXT,
 134               'icons':gtk.TOOLBAR_ICONS,
 135               'both-horiz':gtk.TOOLBAR_BOTH_HORIZ}
 136
 137     def _initialize(self):
 138         style = self._view.get_style()
 139
 140         if style in self.STYLES.keys():
 141             self._view.set_style(self.STYLES[style])
 142
 143         widget_tree = gtk.glade.get_widget_tree(self._view._widget)
 144         self.change_read_state_button = widget_tree.get_widget("toolbar_change_read_state_button")
 145
 146     def style_changed(self, value):
 147         if value in self.STYLES.keys():
 148             self._view.set_style(self.STYLES[value])
 149
 150     def set_change_read_button_state(self, new_state):
 151         self.change_read_state_button.set_active(new_state)
 152
 153 class ApplicationPresenter(MVP.BasicPresenter):
 154     def _initialize(self):
 155         FeedManager._get_instance().connect("update-all-done", self._on_update_all_done)
 156
 157         self._current_item = None
 158
 159         self._init_widgets()
 160         self._init_presenters()
 161         self._restore_state()
 162         self._view.present()
 163
 164     def _init_widgets(self):
 165         widget_tree = self._view.get_widget_tree()
 166
 167         self._itemlist_view_notebook = widget_tree.get_widget('mode_view_notebook')
 168         self._feedlist_view_notebook = widget_tree.get_widget('left_mode_view_notebook')
 169
 170         item_view_container = widget_tree.get_widget('item_view_container')
 171         item_list_container = widget_tree.get_widget('item_list_container')
 172
 173         self.update_all_button = widget_tree.get_widget("toolbar_refresh_all_button")
 174
 175         parent_paned = item_view_container.get_parent()
 176         parent_parent_widget = parent_paned.get_parent()
 177
 178         child_list = []
 179         layout = Config.get(OPTION_PANE_LAYOUT)
 180
 181         if layout not in ("horizontal", "vertical"):
 182             layout = "vertical"
 183
 184         if layout == "vertical":
 185             new_paned = gtk.VPaned()
 186             child_list.append(item_list_container)
 187             child_list.append(item_view_container)
 188         elif layout == "horizontal":
 189             new_paned = gtk.HPaned()
 190             child_list.append(item_view_container)
 191             child_list.append(item_list_container)
 192
 193         for child in child_list:
 194             child.reparent(new_paned)
 195
 196         parent_parent_widget.remove(parent_paned)
 197         parent_parent_widget.add(new_paned)
 198
 199         new_paned.connect("size-allocate", self._view._on_main_sub_pane_size_allocate)
 200         new_paned.set_position(Config.get(OPTION_SUB_PANE_POS))
 201         new_paned.show()
 202
 203     def _init_presenters(self):
 204         widget_tree = self._view.get_widget_tree()
 205         self._toolbar_presenter = ToolbarPresenter(view=ToolbarView(widget_tree.get_widget('toolbar_default')))
 206         self._error_presenter = ErrorPresenter(widget_tree.get_widget('statusbar_error_indicator'))
 207
 208         self._item_view = ItemView(widget_tree.get_widget('item_view_container'))
 209
 210         view = ItemListView(widget_tree.get_widget('item_selection_treeview'))
 211         self._itemlist_presenter = ItemListPresenter(view=view)
 212
 213         view.add_selection_changed_listener(self._item_view)
 214         view.add_selection_changed_listener(self)
 215
 216         view  = FeedsView(widget_tree.get_widget('feed_selection_treeview'))
 217         self._feed_list_presenter = FeedsPresenter(view=view)
 218         view.add_selection_changed_listener(self._itemlist_presenter)
 219         view.add_selection_changed_listener(self._error_presenter)
 220
 221         view.add_mark_all_as_read_listener(self._itemlist_presenter)
 222
 223         self._offline_presenter = OfflineToggle(widget_tree.get_widget('offline_toggle'))
 224
 225         self._status_presenter = StatusPresenter(view = widget_tree.get_widget("main_statusbar"))
 226         #self._find_presenter = FindPresenter(view=FindView(widget_tree.get_widget("find_vbox")))
 227
 228     def set_current_item(self, item):
 229         self._current_item = item
 230         self._current_item_connect_id = item.connect("is-read-changed", self._on_current_item_is_read_changed)
 231
 232     def _restore_state(self):
 233         self._feed_list_presenter.restore_state()
 234
 235     def clear_current_item(self):
 236         if self._current_item:
 237             self._current_item.disconnect(self._current_item_connect_id)
 238             self._current_item = None
 239
 240     def set_current_item_is_read(self, is_read):
 241         if self._current_item:
 242             self._current_item.props.is_read = is_read
 243
 244     def _on_current_item_is_read_changed(self, obj, is_read):
 245         self._toolbar_presenter.set_change_read_button_state(is_read)
 246
 247     def itemlist_selection_changed(self, selection, column):
 248         self.clear_current_item()
 249
 250         (model, treeiter) = selection.get_selected()
 251         if not treeiter: return
 252         item = model.get_value(treeiter, column)
 253         self._toolbar_presenter.set_change_read_button_state(item.is_read)
 254         self.set_current_item(item)
 255
 256     def add_category(self):
 257         self._feed_list_presenter.add_category()
 258
 259     def copy_itemview_text_selection(self):
 260         helpers.set_clipboard_text(self._item_view.get_selected_text())
 261
 262     def check_allocation(self, widget, event):
 263         def check_size(widget, width, height, x, y):
 264             if width == widget.allocation.width and height == widget.allocation.height:
 265                 Config.set(OPTION_WINDOW_SIZE_W, width)
 266                 Config.set(OPTION_WINDOW_SIZE_H, height)
 267
 268             if widget.window and (x, y) == widget.window.get_position():
 269                 Config.set(OPTION_WINDOW_LEFT, x)
 270                 Config.set(OPTION_WINDOW_TOP, y)
 271
 272         config_position = (Config.get(OPTION_WINDOW_LEFT), Config.get(OPTION_WINDOW_TOP))
 273
 274         if (event.width, event.height, event.x, event.y) != \
 275             (widget.allocation.width, widget.allocation.height, config_position[0], config_position[1]):
 276             gobject.timeout_add(1000, check_size, widget, event.width, event.height, event.x, event.y)
 277
 278     def check_main_pane_position(self, widget):
 279         def check_position((position, widget)):
 280             if position == widget.get_position():
 281                 Config.set(OPTION_MAIN_PANE_POS, position)
 282
 283         pos = widget.get_position()
 284
 285         if pos != Config.get(OPTION_MAIN_PANE_POS):
 286             gobject.timeout_add(1000, check_position, (pos, widget))
 287
 288     def check_sub_pane_position(self, widget):
 289         def check_position((position, widget)):
 290             if position == widget.get_position():
 291                 Config.set(OPTION_SUB_PANE_POS, position)
 292
 293         pos = widget.get_position()
 294
 295         if pos != Config.get(OPTION_SUB_PANE_POS):
 296             gobject.timeout_add(1000, check_position, (pos, widget))
 297
 298     def credits(self):
 299         return helpers.credits()
 300
 301     def poll_all(self):
 302         if not self._warn_if_offline():
 303             return
 304
 305         if not FeedManager.is_update_all_running():
 306             FeedManager.update_all_feeds({ "task-start": [ self._on_feed_poll_started ],
 307                                            "task-done": [ self._on_feed_poll_done ] })
 308             self.update_all_button.set_sensitive(True)
 309             self.update_all_button.set_stock_id(gtk.STOCK_STOP)
 310         else:
 311             self.update_all_button.set_sensitive(False)
 312             FeedManager.stop_update_all()
 313
 314     def _on_feed_poll_started(self, handler, feed):
 315         pass
 316
 317     def _on_feed_poll_done(self, handler, data):
 318         pass
 319
 320     def _on_update_all_done(self, obj):
 321         self.update_all_button.set_sensitive(True)
 322         self.update_all_button.set_stock_id(gtk.STOCK_REFRESH)
 323
 324     def poll_current_category(self):
 325         if self._warn_if_offline():
 326             self._poll_categories([self._curr_category])
 327
 328     def poll_current_feed(self):
 329         if self._warn_if_offline():
 330             pm = PollManager.get_instance()
 331             pm.poll([self._curr_feed])
 332
 333     def mark_feed_as_read(self):
 334         self._curr_feed.mark_all_read()
 335
 336     def mark_all_as_read(self):
 337         print "TODO mark_all_as_read"
 338
 339     def remove_selected_feed(self):
 340 #        self._feed_list_presenter.remove_selected_feed()
 341         pass
 342
 343     def show_search(self):
 344 #        self._find_presenter.item_list.signal_connect(Event.ItemSelectionChangedSignal,
 345 #                                                      self._item_view.item_selection_changed)
 346         self._item_view.display_empty_search()
 347         self._itemlist_view_notebook.set_current_page(1)
 348         self._feedlist_view_notebook.set_current_page(1)
 349         self._feedinfo_presenter.hide()
 350
 351     def hide_search(self):
 352 #        self._find_presenter.clear()
 353         self._itemlist_view_notebook.set_current_page(0)
 354         self._feedlist_view_notebook.set_current_page(0)
 355         self._feedinfo_presenter.show()
 356 #        self._find_presenter.item_list.signal_disconnect(Event.ItemSelectionChangedSignal,
 357 #                                                     self._item_view.item_selection_changed)
 358
 359     def _warn_if_offline(self):
 360         offline = Config.get(OPTION_OFFLINE)
 361         will_poll = False
 362
 363         if offline:
 364             response = self._view.show_offline_dialog()
 365
 366             if response == gtk.RESPONSE_OK:
 367                 Config.set(OPTION_OFFLINE, not offline)
 368                 will_poll = True
 369         else:
 370             will_poll = True
 371
 372         return will_poll
 373
 374     def display_previous_feed(self, item = None):
 375         """
 376         Displays the feed before the current selected feed
 377         """
 378         self._feed_list_presenter.select_previous_feed()
 379
 380     def display_next_feed(self, item=None):
 381         """
 382         Displays the feed after the current selected feed
 383         """
 384         self._feed_list_presenter.select_next_feed()
 385         return
 386
 387     def display_next_unread_feed(self):
 388         """
 389         Displays the next feed with an unread item
 390         """
 391         self._feed_list_presenter.select_next_feed(with_unread=True)
 392         pass
 393
 394     def display_previous_item(self, item=None):
 395         """
 396         Displays the item before the current selected item. If the item is the
 397         first item, scrolls to the previous feed
 398         """
 399         is_prev = self._itemlist_presenter.select_previous_item()
 400         if not is_prev:
 401             # TODO HACK - implement select_previous_feed(select_last=True) ...
 402             # ... to select previous feed's last item
 403             self._feed_list_presenter.select_previous_feed()
 404             self._itemlist_presenter.select_last_item()
 405             pass
 406         return
 407
 408     def display_next_item(self, item=None):
 409         """
 410         Displays the item after the current selected item. If the item is the
 411         last item, selectes the next feed. If the current feed is the last
 412         feed in the list, it goes back and selects the first feed
 413         """
 414         is_next = self._itemlist_presenter.select_next_item()
 415         if not is_next:
 416             is_next_feed = self._feed_list_presenter.select_next_feed()
 417             if not is_next_feed:
 418                 self._feed_list_presenter.select_firsteed_feed()
 419         return
 420
 421     def scroll_or_display_next_unread_item(self, item=None):
 422         has_unread_item = False
 423         if not self._item_view.scroll_down():
 424             has_unread_item = self._itemlist_presenter.select_next_unread_item()
 425             if not has_unread_item:
 426                 self._feed_list_presenter.select_next_feed(with_unread=True)
 427         return
 428
 429     def show_preferences_dialog(self, parent):
 430         preferences.show()
 431
 432     def show_feed_properties(self, parent):
 433         feedproperties.show(self._curr_feed)
 434
 435     def quit(self):
 436         self._feed_list_presenter.store_state()
 437         ItemManager.shutdown()
 438         gtk.main_quit()
 439
 440     def _setup_filechooser_dialog(self, title, action, extra_widget_title):
 441         """
 442         Setup the file chooser dialog. This includes an extra widget (a combobox)
 443         to include the categories to import or export
 444         """
 445         dialog = gtk.FileChooserDialog(title, action=action,
 446                                        buttons=(gtk.STOCK_CANCEL,
 447                                                 gtk.RESPONSE_CANCEL,
 448                                                 gtk.STOCK_OK, gtk.RESPONSE_OK))
 449         category_list = []
 450
 451         for category in FeedManager.categories():
 452             category_list.append(category)
 453
 454         model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
 455         combobox = gtk.ComboBox(model)
 456         celltitle = gtk.CellRendererText()
 457         combobox.pack_start(celltitle, False)
 458         combobox.add_attribute(celltitle, 'text', 0)
 459
 460         for category in category_list:
 461             it = model.append()
 462             model.set(it, 0, category.name, 1, category)
 463
 464         combobox.set_active(0)
 465         label = gtk.Label(extra_widget_title)
 466         label.set_alignment(1.0, 0.5)
 467         hbox = gtk.HBox(spacing=6)
 468         hbox.pack_start(label, True, True, 0)
 469         hbox.pack_end(combobox, False, False, 0)
 470         hbox.show_all()
 471
 472         dialog.set_extra_widget(hbox)
 473         return (dialog, combobox)
 474
 475     def import_subscriptions(self, parent):
 476         (dialog, combobox) = self._setup_filechooser_dialog(_("Import Subscriptions"),
 477                                                              gtk.FILE_CHOOSER_ACTION_OPEN,
 478                                                              _("Add new subscriptions in:"))
 479         ffilter = gtk.FileFilter()
 480         ffilter.set_name(_("OPML Files Only"))
 481         ffilter.add_pattern("*.xml")
 482         ffilter.add_pattern("*.opml")
 483         dialog.add_filter(ffilter)
 484         dialog.set_transient_for(parent)
 485         response = dialog.run()
 486         if response == gtk.RESPONSE_OK:
 487             filename = dialog.get_filename()
 488             model = combobox.get_model()
 489             category = model[combobox.get_active()][1]
 490             dialog.hide()
 491             FeedManager.import_opml(filename, category)
 492         dialog.destroy()
 493
 494     def export_subscriptions(self, parent):
 495         (dialog, combobox) = self._setup_filechooser_dialog(_("Export Subscriptions"),
 496                                                              gtk.FILE_CHOOSER_ACTION_SAVE,
 497                                                              _("Select category to export:"))
 498         def selection_changed(widget, dialog):
 499             model = widget.get_model()
 500             category = model[widget.get_active()][1]
 501             dialog.set_current_name("Straw-%s.xml" % category.name)
 502
 503         combobox.connect('changed', selection_changed, dialog)
 504         selection_changed(combobox, dialog)
 505         dialog.set_transient_for(parent)
 506         response = dialog.run()
 507
 508         if response == gtk.RESPONSE_OK:
 509             filename = dialog.get_filename()
 510             model = combobox.get_model()
 511             root_category = model[combobox.get_active()][1]
 512             FeedManager.export_opml(root_category.id, filename)
 513
 514         dialog.destroy()
 515
 516     def subscribe(self):
 517         subscribe_show(parent=self.view._widget)
 518
 519 class ApplicationView(MVP.WidgetView):
 520     """
 521     Widget: straw_main
 522     """
 523     def _initialize(self):
 524         self._initialize_dnd()
 525         self._initialize_window_updater()
 526         self._create_unmodified_accelerator_group()
 527         self._attach_unmodified_accelerator_group()
 528         self._initialize_window()
 529         self._find_toggled = False
 530
 531     def _initialize_window(self):
 532         widget_tree = gtk.glade.get_widget_tree(self._widget)
 533         if Config.get(OPTION_WINDOW_MAX):
 534             self._widget.maximize()
 535         else:
 536             # we use resize here since configure-event seems to
 537             # overwrite the default size if we use set_default_size.
 538             #self._widget.move(Config.get(OPTION_WINDOW_LEFT), Config.get(OPTION_WINDOW_TOP))
 539             #self._widget.resize(Config.get(OPTION_WINDOW_SIZE_W), Config.get(OPTION_WINDOW_SIZE_H))
 540             self._widget.window.move_resize(Config.get(OPTION_WINDOW_LEFT), Config.get(OPTION_WINDOW_TOP),
 541                                             Config.get(OPTION_WINDOW_SIZE_W), Config.get(OPTION_WINDOW_SIZE_H))
 542         self.mmp = widget_tree.get_widget('main_main_pane')
 543         self.msp = widget_tree.get_widget('main_sub_pane')
 544
 545         self.mmp.set_position(Config.get(OPTION_MAIN_PANE_POS))
 546         self.msp.set_position(Config.get(OPTION_SUB_PANE_POS))
 547
 548     def _initialize_dnd(self):
 549         self._widget.drag_dest_set(
 550                 gtk.DEST_DEFAULT_ALL,
 551                 [('_NETSCAPE_URL', 0, 0), ('text/uri-list ', 0, 1),
 552                  ('x-url/http', 0, 2)],
 553                 gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
 554         return
 555
 556     def _initialize_window_updater(self):
 557         #feedlist.signal_connect(Event.AllItemsReadSignal,
 558         #                        lambda signal: self._update_title(feedlist))
 559         #feedlist.signal_connect(Event.ItemReadSignal,
 560         #                        lambda signal: self._update_title(feedlist))
 561         #feedlist.signal_connect(Event.ItemsAddedSignal,
 562         #                        lambda signal: self._update_title(feedlist))
 563         #feedlist.signal_connect(Event.FeedsChangedSignal,
 564         #                        lambda signal: self._update_title(feedlist))
 565         pass
 566
 567     def _update_title(self, flist):
 568         uritems = urfeeds = 0
 569         sfeeds = "feeds"
 570         listfeeds = flist.flatten_list()
 571         for ur in [f.number_of_unread for f in listfeeds]:
 572             if ur:
 573                 uritems += ur
 574                 urfeeds += 1
 575         else:
 576             urfeeds = len(listfeeds)
 577         if urfeeds < 2:
 578             sfeeds = "feed"
 579         item_feed_map = {'uritems': uritems,
 580                          'urfeeds': urfeeds,
 581                          'fstring' : sfeeds}
 582         title = _('%(uritems)d unread in %(urfeeds)d %(fstring)s') % item_feed_map
 583         self._widget.set_title(title + " - %s" % straw.defs.PACKAGE)
 584
 585     # We have a separate accelerator group for the unmodified and
 586     # shifted accelerators, that is, stuff like space, N, P, etc. This
 587     # is so that we can have the find pane work correctly
 588     def _create_unmodified_accelerator_group(self):
 589         xml = gtk.glade.get_widget_tree(self._widget)
 590         agroup = gtk.AccelGroup()
 591         accels = (('feed_mark_as_read', 'R', gtk.gdk.SHIFT_MASK),
 592                   ('feed_mark_all_as_read', 'A', gtk.gdk.SHIFT_MASK),
 593                   ('next_item', 'N', gtk.gdk.SHIFT_MASK),
 594                   ('scroll_unread_items', ' ', 0),
 595                   ('previous_item', 'P', gtk.gdk.SHIFT_MASK))
 596         for widget_name, key, mask in accels:
 597             widget = xml.get_widget(widget_name)
 598             widget.add_accelerator("activate", agroup, ord(key), mask,
 599                                    gtk.ACCEL_VISIBLE)
 600         self._unmodified_accelerator_group = agroup
 601
 602     def _on_category_add_activate(self, *args):
 603         self._presenter.add_category()
 604
 605     def _on_toolbar_change_read_state_button_toggled(self, button):
 606         self._presenter.set_current_item_is_read(button.get_active())
 607
 608     def _attach_unmodified_accelerator_group(self):
 609         self._widget.add_accel_group(self._unmodified_accelerator_group)
 610
 611     def _detach_unmodified_accelerator_group(self):
 612         self._widget.remove_accel_group(self._unmodified_accelerator_group)
 613
 614     def _on_straw_main_destroy_event(self, *args):
 615         return self._presenter.quit()
 616
 617     def _on_straw_main_delete_event(self, *args):
 618         return self._presenter.quit()
 619
 620     def _on_straw_main_window_state_event(self, widget, event):
 621         is_maximized = widget.window.get_state() == gtk.gdk.WINDOW_STATE_MAXIMIZED
 622         Config.set(OPTION_WINDOW_MAX, is_maximized)
 623
 624     def _on_straw_main_configure_event(self, widget, event, *args):
 625         if not (widget.window.get_state() & gtk.gdk.WINDOW_STATE_MAXIMIZED):
 626             self._presenter.check_allocation(widget, event)
 627
 628     def _on_main_main_pane_size_allocate(self, widget, *args):
 629         self._presenter.check_main_pane_position(widget)
 630
 631     def _on_main_sub_pane_size_allocate(self, widget, *args):
 632         self._presenter.check_sub_pane_position(widget)
 633
 634     # Actions menu
 635     def _on_feed_subscribe_activate(self, *args):
 636         self._presenter.subscribe()
 637
 638     def _on_feed_unsubscribe_activate(self, *args):
 639         self._presenter.remove_selected_feed()
 640
 641     def _on_subscription_import_activate(self, *args):
 642         self._presenter.import_subscriptions(self._widget)
 643
 644     def _on_subscription_export_activate(self, *args):
 645         self._presenter.export_subscriptions(self._widget)
 646
 647     def _on_feed_mark_as_read_activate(self, *args):
 648         self._presenter.mark_feed_as_read()
 649
 650     def _on_feed_mark_all_as_read_activate(self, *args):
 651         self._presenter.mark_all_as_read()
 652
 653     def _on_feed_refresh_selected_activate(self, *args):
 654         self._presenter.poll_current_feed()
 655
 656     def _on_subscription_refresh_activate(self, *args):
 657         self._presenter.poll_all()
 658
 659     def _on_quit_activate(self, *args):
 660         return self._presenter.quit()
 661
 662     # Edit menu
 663     def _on_copy_activate(self, *args):
 664         self._presenter.copy_itemview_text_selection()
 665
 666     def _on_find_activate(self, widget, *args):
 667         xml = gtk.glade.get_widget_tree(self._widget)
 668         menu_find = xml.get_widget('menu_find')
 669         accel_label = menu_find.get_child()
 670
 671         if not self._find_toggled:
 672             self._presenter.show_search()
 673             self._detach_unmodified_accelerator_group()
 674             self._find_toggled = True
 675
 676             # save the "Find..." stock text for later recovery
 677             self._old_label_text = accel_label.get_text()
 678             accel_label.set_text(_('Return to feed list...'))
 679
 680         else:
 681             self._presenter.hide_search()
 682             self._attach_unmodified_accelerator_group()
 683             self._find_toggled = False
 684             accel_label.set_text(self._old_label_text)
 685
 686     def _on_preferences_activate(self, *args):
 687         self._presenter.show_preferences_dialog(self._widget)
 688
 689     def _on_feed_information_activate(self, *args):
 690         self._presenter.show_feed_properties(self._widget)
 691
 692     # View menu
 693     def _on_previous_item_activate(self, *args):
 694         self._presenter.display_previous_item()
 695
 696     def _on_next_item_activate(self, *args):
 697         self._presenter.display_next_item()
 698
 699     def _on_next_feed_activate(self, *args):
 700         self._presenter.display_next_feed()
 701
 702     def _on_previous_feed_activate(self, *args):
 703         self._presenter.display_previous_feed()
 704
 705     def _on_next_unread_feed_activate(self, *args):
 706         self._presenter.display_next_unread_feed()
 707
 708     def _on_scroll_unread_items_activate(self, *args):
 709         self._presenter.scroll_or_display_next_unread_item()
 710
 711     # Help menu
 712
 713     def _on_report_problem_activate(self, menuitem, *args):
 714         helpers.url_show("http://bugzilla.gnome.org/simple-bug-guide.cgi?product=straw")
 715
 716     def _on_about_activate(self, menuitem, *args):
 717         widget = self._presenter.credits()
 718         widget.show()
 719
 720     def _on_straw_main_drag_data_received(self, w, context,
 721                                           x, y, data, info, time):
 722         if data and data.format == 8:
 723             url = data.data.split("\n")[0]
 724             subscribe_show("%s" % url, self._widget)
 725             context.finish(True, False, time)
 726         else:
 727             context.finish(False, False, time)
 728
 729     # FIXME
 730     def show_offline_dialog(self):
 731         return helpers.report_offline_status(self._widget)
 732
 733     def get_widget_tree(self):
 734         return gtk.glade.get_widget_tree(self._widget)
 735
 736     def present(self):
 737         self._widget.present()
 738
 739     def should_present(self):
 740         if self._widget.window and self._widget.window.get_state() is not gtk.gdk.WINDOW_STATE_WITHDRAWN:
 741             self._widget.hide()
 742         else:
 743             self._widget.present()
 744
 745
 746 class Application:
 747     def __init__(self):
 748         gnome.program_init(straw.defs.PACKAGE, straw.defs.VERSION)
 749
 750         # initialize threading and environment
 751         gobject.threads_init()
 752
 753         #Config.set(OPTION_OFFLINEnfig.reload_css = os.getenv('STRAW_RELOAD_CSS') is not None
 754
 755         # build tray status icon
 756         image = gtk.Image()
 757         iconfile = os.path.normpath(straw.defs.STRAW_DATA_DIR + "/straw.svg")
 758         pixbuf = gtk.gdk.pixbuf_new_from_file(iconfile)
 759         scaled_buf = pixbuf.scale_simple(16, 16, gtk.gdk.INTERP_BILINEAR)
 760         image.set_from_pixbuf(scaled_buf)
 761         try:
 762             self.tray = gtk.status_icon_new_from_pixbuf(scaled_buf)
 763             self.tray.connect('activate', self._tray_clicked)
 764         except AttributeError:
 765             import egg
 766             import egg.trayicon
 767             self.tray = egg.trayicon.TrayIcon(straw.defs.PACKAGE);
 768             self._eventbox = gtk.EventBox()
 769             self.tray.add(self._eventbox)
 770             self._eventbox.connect('button_press_event', self._tray_clicked)
 771             self._eventbox.connect("drag-data-received", self._on_drag_data_received)
 772             self._eventbox.drag_dest_set(
 773                 gtk.DEST_DEFAULT_ALL,
 774                 [('_NETSCAPE_URL', 0, 0), ('text/uri-list ', 0, 1), ('x-url/http', 0, 2)],
 775                 gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
 776             self._eventbox.add(image)
 777             self.tray.show_all()
 778
 779         self._tooltip = gtk.Tooltips()
 780         self.unread_count = 0
 781         # end build tray status icon
 782
 783         FeedManager.setup(storage_path = "test.db")
 784         FeedManager.init()
 785
 786         ItemManager.setup(storage_path = "test.db")
 787         ItemManager.init()
 788
 789         #FeedManager.import_opml(os.path.join(straw.STRAW_DATA_DIR, "default_subscriptions.opml"))
 790
 791         #if config.first_time:
 792         #    filepath = os.path.join(straw.STRAW_DATA_DIR, "default_subscriptions.opml")
 793         #    feeds.import_opml(filepath)
 794
 795         #ImageCache.initialize()
 796
 797         xml = gtk.glade.XML(os.path.join(straw.defs.STRAW_DATA_DIR, 'straw.glade'), "straw_main", gettext.textdomain())
 798         window = xml.get_widget('straw_main')
 799         self._main_presenter = ApplicationPresenter(view = ApplicationView(window))
 800         self._main_presenter.view.present()
 801
 802         #PollManager.get_instance().start_polling_loop()
 803         # set the default icon for the windows
 804         iconfile = os.path.join(straw.defs.STRAW_DATA_DIR, "straw.svg")
 805         gtk.window_set_default_icon(gtk.gdk.pixbuf_new_from_file(iconfile))
 806
 807         start_services()
 808
 809     def mainloop(self):
 810         gtk.gdk.threads_init()
 811         gtk.gdk.threads_enter()
 812         gtk.main()
 813         gtk.gdk.threads_leave()
 814
 815     def _update(self, flist):
 816         uritems = urfeeds = 0
 817         for ur in [f.number_of_unread for f in flist.flatten_list()]:
 818             if ur:
 819                 uritems += ur
 820                 urfeeds += 1
 821         if uritems == self.unread_count:
 822             return
 823         self.unread_count = uritems
 824         if uritems:
 825             self._tooltip.set_tip(self.tray, _("%d new items")%uritems)
 826             self.tray.show_all()
 827         else:
 828             self.tray.hide()
 829         return
 830
 831     def _tray_clicked(self, widget, event=None):
 832         self._main_presenter.view.should_present()
 833
 834         if event and not (event.button == 1):
 835             return
 836         self._main_presenter.scroll_or_display_next_unread_item()
 837
 838     def _on_drag_data_received(self, widget, context, x, y, data, info, timestamp):
 839         if data and data.format == 8:
 840             url = data.data.split("\n")[0]
 841             subscribe_show(url="%s" % url)
 842             context.finish(True, False, timestamp)
 843         else:
 844             context.finish(False, False, timestamp)
 845         return