src/FukuiNoNamari/bookmark_window.py

   1 # Copyright (C) 2006 by Aiwota Programmer
   2 # aiwotaprog@tetteke.tk
   3 #
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 import pygtk
  19 pygtk.require("2.0")
  20 import gtk
  21 import gtk.glade
  22 import traceback
  23 import gnome
  24 import os.path
  25 import itertools
  26 import sys
  27
  28 from bookmark_core import Bookmark
  29 from bookmark_editwindow import BookmarkEditWindow
  30 from BbsType import bbs_type_exception
  31 import bookmark_list
  32 import uri_opener
  33 import winwrapbase
  34 import session
  35 import config
  36
  37 GLADE_FILENAME = "bookmark_window.glade"
  38
  39 def open():
  40     winwrap = session.get_window(WinWrap.uri)
  41     if winwrap:
  42         # already opened
  43         winwrap.window.present()
  44     else:
  45         winwrap = WinWrap()
  46
  47
  48 class WinWrap(winwrapbase.WinWrapBase):
  49
  50     uri = "namari://bookmarks-manager"
  51
  52     def __init__(self):
  53         self.bookmarklist = bookmark_list.bookmark_list
  54         self.bookmarklist.set_view(self)
  55
  56         glade_path = os.path.join(config.glade_dir, GLADE_FILENAME)
  57         self.widget_tree = gtk.glade.XML(glade_path)
  58         self.window = self.widget_tree.get_widget("window_bookmark")
  59         self.window.connect("destroy", self.on_destroy)
  60         self.treeview_categories = self.widget_tree.get_widget(
  61             "treeview_categories")
  62         self.treeview_categories.connect(
  63             "cursor-changed", self.on_treeview_categories_cursor_changed)
  64         self.treeview_bookmarks = self.widget_tree.get_widget(
  65             "treeview_bookmarks")
  66         self.treeview_bookmarks.connect(
  67             "row-activated", self.on_treeview_bookmarks_row_activated)
  68         self.treeview_bookmarks.connect(
  69             "cursor-changed", self.on_treeview_bookmarks_cursor_changed)
  70         self.treeview_bookmarks.connect(
  71             "button-press-event",
  72             self.on_treeview_bookmarks_button_press_event)
  73         self.statusbar = self.widget_tree.get_widget("statusbar")
  74         self.statusbar.push(
  75             self.statusbar.get_context_id("bookmarks"), "Ready.")
  76         self.menu_bookmark = self.widget_tree.get_widget("menu_bookmark")
  77
  78         self.widget_tree.signal_autoconnect(self)
  79
  80         renderer = gtk.CellRendererText()
  81
  82         treeviewcolumn = gtk.TreeViewColumn("category", renderer, text=0)
  83         treeviewcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  84         self.treeview_categories.append_column(treeviewcolumn)
  85
  86         treeviewcolumn = gtk.TreeViewColumn("bookmark", renderer, text=0)
  87         treeviewcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  88         self.treeview_bookmarks.append_column(treeviewcolumn)
  89
  90         self.treeview_categories.set_fixed_height_mode(True)
  91         self.treeview_bookmarks.set_fixed_height_mode(True)
  92
  93         self.treeview_categories.set_model(gtk.ListStore(str, int))
  94         self.treeview_bookmarks.set_model(gtk.ListStore(str, object))
  95
  96         self.current_category = ""
  97         self.current_category_type = 0
  98
  99         self.update_categories()
 100
 101         self.created()
 102
 103     def on_destroy(self, widget):
 104         self.destroyed()
 105
 106     def get_uri(self):
 107         return self.uri
 108
 109     def destroyed(self):
 110         self.bookmarklist.set_view(None)
 111         winwrapbase.WinWrapBase.destroyed(self)
 112
 113     def destroy(self):
 114         self.window.destroy()
 115
 116     def on_treeview_categories_cursor_changed(self, widget):
 117         selection = self.treeview_categories.get_selection()
 118         model, iter = selection.get_selected()
 119         if model and iter:
 120             category = model.get_value(iter, 0)
 121             category_type = model.get_value(iter, 1)
 122             if category and category != self.current_category:
 123                 self.update_bookmarks(category, category_type)
 124
 125     def _get_selected_bookmark(self):
 126         selection = self.treeview_bookmarks.get_selection()
 127         model, iter = selection.get_selected()
 128         if model and iter:
 129             return model.get_value(iter, 1)
 130
 131     def on_treeview_bookmarks_cursor_changed(self, widget):
 132         bookmark = self._get_selected_bookmark()
 133         if bookmark:
 134             self.statusbar.pop(self.statusbar.get_context_id("bookmarks"))
 135             self.statusbar.push(
 136                 self.statusbar.get_context_id("bookmarks"), bookmark.uri)
 137
 138     def on_treeview_bookmarks_row_activated(self, widget, path, column):
 139         model = self.treeview_bookmarks.get_model()
 140         if model:
 141             iter = model.get_iter(path)
 142             if iter:
 143                 self._open_bookmark(model.get_value(iter, 1))
 144
 145     def on_treeview_bookmarks_button_press_event(self, widget, event):
 146         if event.button == 3:
 147             x = int(event.x)
 148             y = int(event.y)
 149             time = event.time
 150             pthinfo = widget.get_path_at_pos(x, y)
 151             if pthinfo is not None:
 152                 path, col, cellx, celly = pthinfo
 153                 widget.grab_focus()
 154                 widget.set_cursor(path, col, 0)
 155                 self.menu_bookmark.popup(None, None, None, event.button, time)
 156             return True
 157
 158     def on_update_bbsmenu(self, widget):
 159         self.bookmarklist.update_bbsmenu()
 160         self.update_categories()
 161
 162     def _open_bookmark(self, bookmark):
 163         try:
 164             uri_opener.open_uri(bookmark.uri)
 165         except bbs_type_exception.BbsTypeError:
 166             self._open_bookmark_with_web_browser(bookmark)
 167
 168     def _open_bookmark_with_web_browser(self, bookmark):
 169         gnome.url_show(bookmark.uri)
 170
 171     def update_bookmarks(self, category, category_type):
 172         if category_type == 0:
 173             bookmarks = self.bookmarklist.get_bookmark_list_in_category(
 174                 category)
 175         else:
 176             bookmarks = self.bookmarklist.get_non_category_bookmark()
 177
 178         model = self.treeview_bookmarks.get_model()
 179         model.clear()
 180
 181         for bookmark in bookmarks:
 182             model.append([bookmark.name, bookmark])
 183         self.treeview_bookmarks.set_model(model)
 184
 185         self.current_category = category
 186         self.current_category_type = category_type
 187
 188         category_model = self.treeview_categories.get_model()
 189         if category_model:
 190             for row in category_model:
 191                 text = row.model.get_value(row.iter, 0)
 192                 cat_type = row.model.get_value(row.iter, 1)
 193                 if text == category and cat_type == category_type:
 194                     selection = self.treeview_categories.get_selection()
 195                     selection.select_iter(row.iter)
 196                     self.treeview_categories.scroll_to_cell(row.path)
 197                     break
 198
 199         self.statusbar.pop(self.statusbar.get_context_id("bookmarks"))
 200
 201     def update_categories(self):
 202         model = self.treeview_categories.get_model()
 203         model.clear()
 204         categories = self.bookmarklist.get_category_list()
 205         model.append(["Non Category", 1])
 206         for category in categories:
 207             model.append([category, 0])
 208         self.treeview_categories.set_model(model)
 209
 210         if self.current_category:
 211             self.update_bookmarks(self.current_category,
 212                                   self.current_category_type)
 213         else:
 214             self.update_bookmarks("", 0)
 215
 216     def on_editbookmark_complete(self, old_bookmark, new_bookmark):
 217         changed = False
 218         changed = changed or old_bookmark.name != new_bookmark.name
 219         changed = changed or old_bookmark.uri != new_bookmark.uri
 220         changed = changed or \
 221                   len(old_bookmark.categories) != len(new_bookmark.categories)
 222         if not changed:
 223             for cat, kat in itertools.izip(old_bookmark.categories,
 224                                            new_bookmark.categories):
 225                 if cat not in new_bookmark.categories:
 226                     changed = True
 227                     break
 228                 if kat not in old_bookmark.categories:
 229                     changed = True
 230                     break
 231         if changed:
 232             old_bookmark.name = new_bookmark.name
 233             old_bookmark.uri = new_bookmark.uri
 234             old_bookmark.categories = new_bookmark.categories
 235             self.update_categories()
 236             self.bookmarklist.save()
 237         else:
 238             print "not changed"
 239
 240     def on_newbookmark_complete(self, bookmark):
 241         self.bookmarklist.add_new_bookmark(bookmark)
 242         self.update_categories()
 243
 244     # menu handler
 245
 246     def on_new_activate(self, widget):
 247         BookmarkEditWindow(self.on_newbookmark_complete)
 248
 249     def on_open_activate(self, widget):
 250         bookmark = self._get_selected_bookmark()
 251         if bookmark:
 252             self._open_bookmark(bookmark)
 253
 254     def on_open_web_activate(self, widget):
 255         bookmark = self._get_selected_bookmark()
 256         if bookmark:
 257             self._open_bookmark_with_web_browser(bookmark)
 258
 259     def on_properties_activate(self, widget):
 260         bookmark = self._get_selected_bookmark()
 261         if bookmark:
 262             BookmarkEditWindow(
 263                 lambda new_bookmark: \
 264                 self.on_editbookmark_complete(bookmark, new_bookmark),
 265                 bookmark)
 266
 267     def on_save_activate(self, widget):
 268         self.bookmarklist.save()
 269
 270     def on_close_activate(self, widget):
 271         self.destroy()
 272
 273     def on_quit_activate(self, widget):
 274         session.main_quit()
 275
 276     def on_delete_activate(self, widget):
 277         bookmark = self._get_selected_bookmark()
 278         if bookmark:
 279             self.bookmarklist.delete_bookmark(bookmark)
 280             self.update_categories()
 281
 282     def on_refresh_bbsmenu_activate(self, widget):
 283         self.bookmarklist.update_bbsmenu()
 284         self.update_categories()