OSDN Git Service

Add bookmark.
[fukui-no-namari/fukui-no-namari.git] / 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
27 from bookmark_core import Bookmark
28 from bookmark_editwindow import BookmarkEditWindow
29 from BbsType import bbs_type_exception
30 import bookmark_list
31 import uri_opener
32 import winwrapbase
33 import session
34
35 GLADE_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)),
36                          "..", "data")
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(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()