/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to olive/window.py

  • Committer: Vincent Ladeuil
  • Date: 2008-05-05 18:16:46 UTC
  • mto: (487.1.1 gtk)
  • mto: This revision was merged to the branch mainline in revision 490.
  • Revision ID: v.ladeuil+lp@free.fr-20080505181646-n95l8ltw2u6jtr26
Fix bug #187283 fix replacing _() by _i18n().

* genpot.sh 
Remove duplication. Add the ability to specify the genrated pot
file on command-line for debugging purposes.

* po/olive-gtk.pot:
Regenerated.

* __init__.py, branch.py, branchview/treeview.py, checkout.py,
commit.py, conflicts.py, diff.py, errors.py, initialize.py,
merge.py, nautilus-bzr.py, olive/__init__.py, olive/add.py,
olive/bookmark.py, olive/guifiles.py, olive/info.py,
olive/menu.py, olive/mkdir.py, olive/move.py, olive/remove.py,
olive/rename.py, push.py, revbrowser.py, status.py, tags.py:
Replace all calls to _() by calls to _i18n(), the latter being
defined in __init__.py and imported in the other modules from
there. This fix the problem encountered countless times when
running bzr selftest and getting silly error messages about
boolean not being callables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/window.py
1
 
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
2
 
# Some parts of the code are:
3
 
# Copyright (C) 2005, 2006 by Canonical Ltd
4
 
#
5
 
# This program is free software; you can redistribute it and/or modify
6
 
# it under the terms of the GNU General Public License as published by
7
 
# the Free Software Foundation; either version 2 of the License, or
8
 
# (at your option) any later version.
9
 
#
10
 
# This program is distributed in the hope that it will be useful,
11
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
# GNU General Public License for more details.
14
 
#
15
 
# You should have received a copy of the GNU General Public License
16
 
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
19
 
import os
20
 
import sys
21
 
import gtk
22
 
import gobject
23
 
 
24
 
from bzrlib.plugins.gtk import _i18n, icon_path
25
 
 
26
 
 
27
 
class OliveGui(gtk.Window):
28
 
    """ Olive main window """
29
 
    
30
 
    def __init__(self, calling_app):
31
 
        # Pointer to calling instance for signal connection
32
 
        self.signal = calling_app
33
 
        
34
 
        # Initialise window
35
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
36
 
        self.set_title(_i18n("Olive - Bazaar GUI"))
37
 
        self.set_icon_list(gtk.gdk.pixbuf_new_from_file(icon_path("oliveicon2.png")),
38
 
                           gtk.gdk.pixbuf_new_from_file(icon_path("olive-gtk.png")),
39
 
                           # Who has the svg version of the icon? Would be nice to include
40
 
                           #gtk.gdk.pixbuf_new_from_file(icon_path("olive.svg"))
41
 
                           )
42
 
        self.set_property("width-request", 700)
43
 
        self.set_property("height-request", 400)
44
 
        
45
 
        self.connect("destroy", self.destroy)
46
 
        self.connect("delete_event", self.signal.on_window_main_delete_event)
47
 
        
48
 
        # Accelerator group to Quit program
49
 
        accelgroup = gtk.AccelGroup()
50
 
        self.add_accel_group(accelgroup)
51
 
        self.quit_action = gtk.Action(_i18n("Quit"), None, None, gtk.STOCK_QUIT)
52
 
        self.quit_action.connect('activate', self.signal.on_window_main_delete_event)
53
 
        actiongroup = gtk.ActionGroup('QuitAction')
54
 
        actiongroup.add_action_with_accel(self.quit_action, None)
55
 
        self.quit_action.set_accel_group(accelgroup)
56
 
        self.quit_action.connect_accelerator()
57
 
        
58
 
        # High level build up of window
59
 
        self.vbox = gtk.VBox(False, 0)
60
 
        self.add(self.vbox)
61
 
        
62
 
        # Menu bar
63
 
        self._create_menubar()
64
 
        self.vbox.pack_start(self.mb, False, False, 0)
65
 
        
66
 
        # Toolbar
67
 
        self._create_toolbar()
68
 
        self.vbox.pack_start(self.tb, False, False, 0)
69
 
        
70
 
        # Locationbar
71
 
        self._create_locationbar()
72
 
        self.vbox.pack_start(self.locationbar, False, False, 0)
73
 
        
74
 
        # Main area
75
 
        self.hpaned_main = gtk.HPaned()
76
 
        self._create_bookmarklist()
77
 
        self.hpaned_main.add(self.scrolledwindow_left)
78
 
        self._create_filelist()
79
 
        self.hpaned_main.add(self.scrolledwindow_right)
80
 
        self.vbox.pack_start(self.hpaned_main, True, True, 0)
81
 
        
82
 
        # Statusbar
83
 
        self.statusbar = gtk.Statusbar()
84
 
        self.vbox.pack_end(self.statusbar, False, False, 0)
85
 
    
86
 
    def show(self):
87
 
        self.show_all()        
88
 
    
89
 
    def destroy(self, widget=None, data=None):
90
 
        """ Ends the program """
91
 
        gtk.main_quit()
92
 
 
93
 
    def _create_menubar(self):
94
 
        self.mb = gtk.MenuBar()
95
 
        
96
 
        # File menu
97
 
        self.mb_file = gtk.MenuItem(_i18n("_File"))
98
 
        self.mb_file_menu = gtk.Menu()
99
 
        
100
 
        self.mb_file_add = gtk.ImageMenuItem(gtk.STOCK_ADD, _i18n("_Add file(s)"))
101
 
        self.mb_file_add.connect('activate', self.signal.on_menuitem_add_files_activate)
102
 
        self.mb_file_menu.append(self.mb_file_add)
103
 
        
104
 
        self.mb_file_remove = gtk.ImageMenuItem(gtk.STOCK_REMOVE, _i18n("_Remove file(s)"))
105
 
        self.mb_file_remove.connect('activate', self.signal.on_menuitem_remove_file_activate)
106
 
        self.mb_file_menu.append(self.mb_file_remove)
107
 
        
108
 
        self.mb_file_menu.append(gtk.SeparatorMenuItem())
109
 
        
110
 
        self.mb_file_bookmark = gtk.MenuItem(_i18n("_Bookmark current directory"))
111
 
        self.mb_file_bookmark.connect('activate', self.signal.on_menuitem_file_bookmark_activate)
112
 
        self.mb_file_menu.append(self.mb_file_bookmark)
113
 
        
114
 
        self.mb_file_mkdir = gtk.MenuItem(_i18n("_Make directory"))
115
 
        self.mb_file_mkdir.connect('activate', self.signal.on_menuitem_file_make_directory_activate)
116
 
        self.mb_file_menu.append(self.mb_file_mkdir)
117
 
        
118
 
        self.mb_file_menu.append(gtk.SeparatorMenuItem())
119
 
        
120
 
        self.mb_file_rename = gtk.MenuItem(_i18n("_Rename"))
121
 
        self.mb_file_rename.connect('activate', self.signal.on_menuitem_file_rename_activate)
122
 
        self.mb_file_menu.append(self.mb_file_rename)
123
 
        
124
 
        self.mb_file_move = gtk.MenuItem(_i18n("_Move"))
125
 
        self.mb_file_move.connect('activate', self.signal.on_menuitem_file_move_activate)
126
 
        self.mb_file_menu.append(self.mb_file_move)
127
 
        
128
 
        self.mb_file_annotate = gtk.MenuItem(_i18n("_Annotate"))
129
 
        self.mb_file_annotate.connect('activate', self.signal.on_menuitem_file_annotate_activate)
130
 
        self.mb_file_menu.append(self.mb_file_annotate)
131
 
        
132
 
        self.mb_file_menu.append(gtk.SeparatorMenuItem())
133
 
        
134
 
        self.mb_file_quit = self.quit_action.create_menu_item()
135
 
        self.mb_file_menu.append(self.mb_file_quit)
136
 
        
137
 
        self.mb_file.set_submenu(self.mb_file_menu)
138
 
        self.mb.append(self.mb_file)
139
 
        
140
 
        # View menu
141
 
        self.mb_view = gtk.MenuItem(_i18n("_View"))
142
 
        self.mb_view_menu = gtk.Menu()
143
 
        
144
 
        self.mb_view_showhidden = gtk.CheckMenuItem(_i18n("Show _hidden files"))
145
 
        self.mb_view_showhidden.connect('activate', self.signal.on_menuitem_view_show_hidden_files_activate)
146
 
        self.mb_view_menu.append(self.mb_view_showhidden)
147
 
        
148
 
        self.mb_view_showignored = gtk.CheckMenuItem(_i18n("Show _ignored files"))
149
 
        self.mb_view_showignored.connect('activate', self.signal.on_menuitem_view_show_ignored_files_activate)
150
 
        self.mb_view_menu.append(self.mb_view_showignored)
151
 
        
152
 
        self.mb_view_menu.append(gtk.SeparatorMenuItem())
153
 
        
154
 
        self.mb_view_refresh = gtk.ImageMenuItem(gtk.STOCK_REFRESH, _i18n("_Refresh"))
155
 
        self.mb_view_refresh.connect('activate', self.signal.on_menuitem_view_refresh_activate)
156
 
        self.mb_view_menu.append(self.mb_view_refresh)
157
 
        
158
 
        self.mb_view.set_submenu(self.mb_view_menu)
159
 
        self.mb.append(self.mb_view)
160
 
        
161
 
        # Branch menu
162
 
        self.mb_branch = gtk.MenuItem(_i18n("_Branch"))
163
 
        self.mb_branch_menu = gtk.Menu()
164
 
        
165
 
        self.mb_branch_initialize = gtk.MenuItem(_i18n("_Initialize"))
166
 
        self.mb_branch_initialize.connect('activate', self.signal.on_menuitem_branch_initialize_activate)
167
 
        self.mb_branch_menu.append(self.mb_branch_initialize)
168
 
        
169
 
        self.mb_branch_get = gtk.MenuItem(_i18n("_Get"))
170
 
        self.mb_branch_get.connect('activate', self.signal.on_menuitem_branch_get_activate)
171
 
        self.mb_branch_menu.append(self.mb_branch_get)
172
 
        
173
 
        self.mb_branch_checkout = gtk.MenuItem(_i18n("C_heckout"))
174
 
        self.mb_branch_checkout.connect('activate', self.signal.on_menuitem_branch_checkout_activate)
175
 
        self.mb_branch_menu.append(self.mb_branch_checkout)
176
 
        
177
 
        self.mb_branch_menu.append(gtk.SeparatorMenuItem())
178
 
        
179
 
        self.mb_branch_pull = gtk.ImageMenuItem(_i18n("Pu_ll"))
180
 
        pullimage = gtk.Image()
181
 
        pullimage.set_from_file(icon_path("pull16.png"))
182
 
        self.mb_branch_pull.set_image(pullimage)
183
 
        self.mb_branch_pull.connect('activate', self.signal.on_menuitem_branch_pull_activate)
184
 
        self.mb_branch_menu.append(self.mb_branch_pull)
185
 
        
186
 
        self.mb_branch_push = gtk.ImageMenuItem(_i18n("Pu_sh"))
187
 
        pushimage = gtk.Image()
188
 
        pushimage.set_from_file(icon_path("push16.png"))
189
 
        self.mb_branch_push.set_image(pushimage)
190
 
        self.mb_branch_push.connect('activate', self.signal.on_menuitem_branch_push_activate)
191
 
        self.mb_branch_menu.append(self.mb_branch_push)
192
 
        
193
 
        self.mb_branch_update = gtk.MenuItem(_i18n("_Update"))
194
 
        self.mb_branch_update.connect('activate', self.signal.on_menuitem_branch_update_activate)
195
 
        self.mb_branch_menu.append(self.mb_branch_update)
196
 
        
197
 
        self.mb_branch_menu.append(gtk.SeparatorMenuItem())
198
 
        
199
 
        self.mb_branch_revert = gtk.ImageMenuItem(_i18n("_Revert all changes"))
200
 
        revertimage = gtk.Image()
201
 
        revertimage.set_from_stock(gtk.STOCK_REVERT_TO_SAVED, gtk.ICON_SIZE_MENU)
202
 
        self.mb_branch_revert.set_image(revertimage)
203
 
        self.mb_branch_revert.connect('activate', self.signal.on_menuitem_branch_revert_activate)
204
 
        self.mb_branch_menu.append(self.mb_branch_revert)
205
 
        
206
 
        self.mb_branch_merge = gtk.MenuItem(_i18n("_Merge"))
207
 
        self.mb_branch_merge.connect('activate', self.signal.on_menuitem_branch_merge_activate)
208
 
        self.mb_branch_menu.append(self.mb_branch_merge)
209
 
        
210
 
        self.mb_branch_commit = gtk.ImageMenuItem(_i18n("_Commit"))
211
 
        commitimage = gtk.Image()
212
 
        commitimage.set_from_file(icon_path("commit16.png"))
213
 
        self.mb_branch_commit.set_image(commitimage)
214
 
        self.mb_branch_commit.connect('activate', self.signal.on_menuitem_branch_commit_activate)
215
 
        self.mb_branch_menu.append(self.mb_branch_commit)
216
 
        
217
 
        self.mb_branch_menu.append(gtk.SeparatorMenuItem())
218
 
        
219
 
        self.mb_branch_tags = gtk.ImageMenuItem(_i18n("Ta_gs"))
220
 
        tagsimage = gtk.Image()
221
 
        tagsimage.set_from_file(icon_path("tag-16.png"))
222
 
        self.mb_branch_tags.set_image(tagsimage)
223
 
        self.mb_branch_tags.connect('activate', self.signal.on_menuitem_branch_tags_activate)
224
 
        self.mb_branch_menu.append(self.mb_branch_tags)
225
 
        
226
 
        self.mb_branch_status = gtk.MenuItem(_i18n("S_tatus"))
227
 
        self.mb_branch_status.connect('activate', self.signal.on_menuitem_branch_status_activate)
228
 
        self.mb_branch_menu.append(self.mb_branch_status)
229
 
        
230
 
        self.mb_branch_missingrevisions = gtk.MenuItem(_i18n("Missing _revisions"))
231
 
        self.mb_branch_missingrevisions.connect('activate', self.signal.on_menuitem_branch_missing_revisions_activate)
232
 
        self.mb_branch_menu.append(self.mb_branch_missingrevisions)
233
 
        
234
 
        self.mb_branch_conflicts = gtk.MenuItem(_i18n("Con_flicts"))
235
 
        self.mb_branch_conflicts.connect('activate', self.signal.on_menuitem_branch_conflicts_activate)
236
 
        self.mb_branch_menu.append(self.mb_branch_conflicts)
237
 
        
238
 
        self.mb_branch.set_submenu(self.mb_branch_menu)
239
 
        self.mb.append(self.mb_branch)
240
 
        
241
 
        # Statistics menu
242
 
        self.mb_statistics = gtk.MenuItem(_i18n("_Statistics"))
243
 
        self.mb_statistics_menu = gtk.Menu()
244
 
        
245
 
        self.mb_statistics_differences = gtk.ImageMenuItem(_i18n("_Differences"))
246
 
        diffimage = gtk.Image()
247
 
        diffimage.set_from_file(icon_path("diff16.png"))
248
 
        self.mb_statistics_differences.set_image(diffimage)
249
 
        self.mb_statistics_differences.connect('activate', self.signal.on_menuitem_stats_diff_activate)
250
 
        self.mb_statistics_menu.append(self.mb_statistics_differences)
251
 
        
252
 
        self.mb_statistics_log = gtk.ImageMenuItem(_i18n("_Log"))
253
 
        logimage = gtk.Image()
254
 
        logimage.set_from_file(icon_path("log16.png"))
255
 
        self.mb_statistics_log.set_image(logimage)
256
 
        self.mb_statistics_log.connect('activate', self.signal.on_menuitem_stats_log_activate)
257
 
        self.mb_statistics_menu.append(self.mb_statistics_log)
258
 
        
259
 
        self.mb_statistics_information = gtk.MenuItem(_i18n("_Information"))
260
 
        self.mb_statistics_information.connect('activate', self.signal.on_menuitem_stats_infos_activate)
261
 
        self.mb_statistics_menu.append(self.mb_statistics_information)
262
 
        
263
 
        self.mb_statistics.set_submenu(self.mb_statistics_menu)
264
 
        self.mb.append(self.mb_statistics)
265
 
        
266
 
        # Help menu
267
 
        self.mb_help = gtk.MenuItem(_i18n("Help"))
268
 
        self.mb_help_menu = gtk.Menu()
269
 
        
270
 
        self.mb_help_about = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
271
 
        self.mb_help_about.connect('activate', self.signal.on_about_activate)
272
 
        self.mb_help_menu.append(self.mb_help_about)
273
 
        
274
 
        self.mb_help.set_submenu(self.mb_help_menu)
275
 
        self.mb.append(self.mb_help)
276
 
    
277
 
    def _create_toolbar(self):
278
 
        self.tb = gtk.Toolbar()
279
 
        
280
 
        self.tb_refresh_icon = gtk.Image()
281
 
        self.tb_refresh_icon.set_from_file(icon_path("refresh.png"))
282
 
        self.tb_refresh = gtk.ToolButton(self.tb_refresh_icon, _i18n("Refresh"))
283
 
        self.tb_refresh.connect('clicked', self.signal.on_menuitem_view_refresh_activate)
284
 
        self.tb.add(self.tb_refresh)
285
 
        
286
 
        self.tb_diff_icon = gtk.Image()
287
 
        self.tb_diff_icon.set_from_file(icon_path("diff.png"))
288
 
        self.tb_diff = gtk.ToolButton(self.tb_diff_icon, _i18n("Diff"))
289
 
        self.tb_diff.connect('clicked', self.signal.on_menuitem_stats_diff_activate)
290
 
        self.tb.add(self.tb_diff)
291
 
        
292
 
        self.tb_log_icon = gtk.Image()
293
 
        self.tb_log_icon.set_from_file(icon_path("log.png"))
294
 
        self.tb_log = gtk.ToolButton(self.tb_log_icon, _i18n("Log"))
295
 
        self.tb_log.connect('clicked', self.signal.on_menuitem_stats_log_activate)
296
 
        self.tb.add(self.tb_log)
297
 
        
298
 
        self.tb.add(gtk.SeparatorToolItem())
299
 
        
300
 
        self.tb_commit_icon = gtk.Image()
301
 
        self.tb_commit_icon.set_from_file(icon_path("commit.png"))
302
 
        self.tb_commit = gtk.ToolButton(self.tb_commit_icon, _i18n("Commit"))
303
 
        self.tb_commit.connect('clicked', self.signal.on_menuitem_branch_commit_activate)
304
 
        self.tb.add(self.tb_commit)
305
 
        
306
 
        self.tb.add(gtk.SeparatorToolItem())
307
 
        
308
 
        self.tb_pull_icon = gtk.Image()
309
 
        self.tb_pull_icon.set_from_file(icon_path("pull.png"))
310
 
        self.tb_pull = gtk.ToolButton(self.tb_pull_icon, _i18n("Pull"))
311
 
        self.tb_pull.connect('clicked', self.signal.on_menuitem_branch_pull_activate)
312
 
        self.tb.add(self.tb_pull)
313
 
        
314
 
        self.tb_push_icon = gtk.Image()
315
 
        self.tb_push_icon.set_from_file(icon_path("push.png"))
316
 
        self.tb_push = gtk.ToolButton(self.tb_push_icon, _i18n("Push"))
317
 
        self.tb_push.connect('clicked', self.signal.on_menuitem_branch_push_activate)
318
 
        self.tb.add(self.tb_push)
319
 
        
320
 
        self.tb_update_icon = gtk.Image()
321
 
        self.tb_update_icon.set_from_file(icon_path("pull.png"))
322
 
        self.tb_update = gtk.ToolButton(self.tb_update_icon, _i18n("Update"))
323
 
        self.tb_update.connect('clicked', self.signal.on_menuitem_branch_update_activate)
324
 
        self.tb.add(self.tb_update)
325
 
    
326
 
    def _create_locationbar(self):
327
 
        """ Creates the location bar, including the history widgets """
328
 
        self.locationbar = gtk.HBox()
329
 
        
330
 
        self.button_location_up = gtk.Button()
331
 
        self.button_location_up.set_relief(gtk.RELIEF_NONE)
332
 
        image_location_up = gtk.Image()
333
 
        image_location_up.set_from_stock(gtk.STOCK_GO_UP, gtk.ICON_SIZE_BUTTON)
334
 
        self.button_location_up.add(image_location_up)
335
 
        self.button_location_up.connect("clicked", self.signal.on_button_location_up_clicked)
336
 
        self.locationbar.pack_start(self.button_location_up, False, False, 0)
337
 
        
338
 
        self.entry_location = gtk.Entry()
339
 
        self.entry_location.connect("activate", self.signal.on_button_location_jump_clicked)
340
 
        self.locationbar.pack_start(self.entry_location, True, True, 0)
341
 
        
342
 
        self.location_status = gtk.Image()
343
 
        self.location_status.set_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_BUTTON)
344
 
        self.locationbar.pack_start(self.location_status, False, False, 0)
345
 
        
346
 
        self.button_location_jump = gtk.Button(stock=gtk.STOCK_JUMP_TO)
347
 
        self.button_location_jump.set_relief(gtk.RELIEF_NONE)
348
 
        self.button_location_jump.connect("clicked", self.signal.on_button_location_jump_clicked)
349
 
        self.locationbar.pack_start(self.button_location_jump, False, False, 0)
350
 
        
351
 
        self.locationbar.pack_start(gtk.VSeparator(), False, False, 0)
352
 
        
353
 
        self.checkbutton_history = gtk.CheckButton(_i18n("H_istory Mode"))
354
 
        self.checkbutton_history.connect("toggled", self.signal.on_checkbutton_history_toggled)
355
 
        self.locationbar.pack_start(self.checkbutton_history, False, False, 0)
356
 
        
357
 
        self.entry_history_revno = gtk.Entry()
358
 
        self.entry_history_revno.set_property("width-request", 75)
359
 
        self.entry_history_revno.set_sensitive(False)
360
 
        self.entry_history_revno.connect("activate", self.signal.on_entry_history_revno_activate)
361
 
        self.locationbar.pack_start(self.entry_history_revno, False, False, 0)
362
 
        
363
 
        self.button_history_browse = gtk.Button()
364
 
        self.button_history_browse.set_sensitive(False)
365
 
        self.image_history_browse = gtk.Image()
366
 
        self.image_history_browse.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
367
 
        self.button_history_browse.add(self.image_history_browse)
368
 
        self.button_history_browse.connect("clicked", self.signal.on_button_history_browse_clicked)
369
 
        self.locationbar.pack_start(self.button_history_browse, False, False, 0)
370
 
    
371
 
    def _create_bookmarklist(self):
372
 
        """ Creates the bookmark list (a ListStore in a TreeView in a ScrolledWindow)"""
373
 
        self.scrolledwindow_left = gtk.ScrolledWindow()
374
 
        self.scrolledwindow_left.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
375
 
        
376
 
        self.treeview_left = gtk.TreeView()
377
 
        self.treeview_left.connect("button-press-event", self.signal.on_treeview_left_button_press_event)
378
 
        self.treeview_left.connect("row-activated", self.signal.on_treeview_left_row_activated)
379
 
        self.scrolledwindow_left.add(self.treeview_left)
380
 
 
381
 
        self.bookmarklist = gtk.ListStore(gobject.TYPE_STRING, 
382
 
                                          gobject.TYPE_STRING, 
383
 
                                          gobject.TYPE_STRING)
384
 
        self.treeview_left.set_model(self.bookmarklist)
385
 
        
386
 
        icon = gtk.CellRendererPixbuf()
387
 
        cell = gtk.CellRendererText()
388
 
        
389
 
        col_bookmark = gtk.TreeViewColumn(_i18n('Bookmarks'))
390
 
        col_bookmark.pack_start(icon, False)
391
 
        col_bookmark.pack_start(cell, False)
392
 
        col_bookmark.set_attributes(icon, stock_id=2)
393
 
        col_bookmark.add_attribute(cell, 'text', 0)
394
 
        self.treeview_left.append_column(col_bookmark)
395
 
    
396
 
    def _create_filelist(self):
397
 
        """ Creates the file list (a ListStore in a TreeView in a ScrolledWindow)"""
398
 
        self.scrolledwindow_right = gtk.ScrolledWindow()
399
 
        self.scrolledwindow_right.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
400
 
        
401
 
        self.treeview_right = gtk.TreeView()
402
 
        self.treeview_right.connect("button-press-event", self.signal.on_treeview_right_button_press_event)
403
 
        self.treeview_right.connect("row-activated", self.signal.on_treeview_right_row_activated)
404
 
        self.scrolledwindow_right.add(self.treeview_right)
405
 
        
406
 
        # Model: [ icon, dir, name, status text, status, size (int), size (human), mtime (int), mtime (local), fileid ]
407
 
        self.filelist = gtk.ListStore(gobject.TYPE_STRING,
408
 
                                      gobject.TYPE_BOOLEAN,
409
 
                                      gobject.TYPE_STRING,
410
 
                                      gobject.TYPE_STRING,
411
 
                                      gobject.TYPE_STRING,
412
 
                                      gobject.TYPE_STRING,
413
 
                                      gobject.TYPE_STRING,
414
 
                                      gobject.TYPE_INT,
415
 
                                      gobject.TYPE_STRING,
416
 
                                      gobject.TYPE_STRING)
417
 
        self.treeview_right.set_model(self.filelist)
418
 
        
419
 
        # Set up the cells
420
 
        cellpb = gtk.CellRendererPixbuf()
421
 
        cell = gtk.CellRendererText()
422
 
        # For columns that get a different text color based on status (4)
423
 
        cellstatus = gtk.CellRendererText()
424
 
        
425
 
        self.col_filename = gtk.TreeViewColumn(_i18n('Filename'))
426
 
        self.col_filename.pack_start(cellpb, False)
427
 
        self.col_filename.pack_start(cell, True)
428
 
        self.col_filename.set_attributes(cellpb, stock_id=0)
429
 
        self.col_filename.add_attribute(cell, 'text', 2)
430
 
        self.col_filename.set_resizable(True)
431
 
        self.treeview_right.append_column(self.col_filename)
432
 
        
433
 
        self.col_status = gtk.TreeViewColumn(_i18n('Status'))
434
 
        self.col_status.pack_start(cellstatus, True)
435
 
        self.col_status.add_attribute(cellstatus, 'text', 3)
436
 
        self.col_status.set_cell_data_func(cellstatus, self._map_status_color)
437
 
        self.col_status.set_resizable(True)
438
 
        self.treeview_right.append_column(self.col_status)
439
 
        
440
 
        self.col_size = gtk.TreeViewColumn(_i18n('Size'))
441
 
        self.col_size.pack_start(cell, True)
442
 
        self.col_size.add_attribute(cell, 'text', 6)
443
 
        self.col_size.set_resizable(True)
444
 
        self.treeview_right.append_column(self.col_size)
445
 
        
446
 
        self.col_mtime = gtk.TreeViewColumn(_i18n('Last modified'))
447
 
        self.col_mtime.pack_start(cell, True)
448
 
        self.col_mtime.add_attribute(cell, 'text', 8)
449
 
        self.col_mtime.set_resizable(True)
450
 
        self.treeview_right.append_column(self.col_mtime)
451
 
        
452
 
        # Set up the properties of the TreeView
453
 
        self.treeview_right.set_headers_visible(True)
454
 
        self.treeview_right.set_headers_clickable(True)
455
 
        self.treeview_right.set_search_column(1)
456
 
        
457
 
        # Set up sorting
458
 
        self.filelist.set_sort_func(13, self.signal._sort_filelist_callback, None)
459
 
        self.filelist.set_sort_column_id(13, gtk.SORT_ASCENDING)
460
 
        self.col_filename.set_sort_column_id(13)
461
 
        self.col_status.set_sort_column_id(3)
462
 
        self.col_size.set_sort_column_id(5)
463
 
        self.col_mtime.set_sort_column_id(7)
464
 
    
465
 
    def _map_status_color(self, column, cell, model, iter):
466
 
        status = model.get_value(iter, 4)
467
 
        if status == 'unchanged':
468
 
            colorstatus = gtk.gdk.color_parse('black')
469
 
            weight = 400 # standard value
470
 
        elif status == 'removed':
471
 
            colorstatus = gtk.gdk.color_parse('red')
472
 
            weight = 800
473
 
        elif status == 'added':
474
 
            colorstatus = gtk.gdk.color_parse('green')
475
 
            weight = 800
476
 
        elif status == 'modified':
477
 
            colorstatus = gtk.gdk.color_parse("#FD00D3")
478
 
            weight = 800
479
 
        elif status == 'renamed':
480
 
            colorstatus = gtk.gdk.color_parse('blue')
481
 
            weight = 800
482
 
        elif status == 'ignored':
483
 
            colorstatus = gtk.gdk.color_parse('grey')
484
 
            weight = 600
485
 
        else: # status == unknown
486
 
            colorstatus = gtk.gdk.color_parse('orange')
487
 
            weight = 800
488
 
        cell.set_property('foreground-gdk', colorstatus)
489
 
        cell.set_property('weight', weight)
490
 
    
491
 
    def set_view_to_localbranch(self, notbranch=False):
492
 
        """ Change the sensitivity of gui items to reflect the fact that the path is a branch or not"""
493
 
        self.mb_branch_initialize.set_sensitive(notbranch)
494
 
        self.mb_branch_get.set_sensitive(notbranch)
495
 
        self.mb_branch_checkout.set_sensitive(notbranch)
496
 
        self.mb_branch_pull.set_sensitive(not notbranch)
497
 
        self.mb_branch_push.set_sensitive(not notbranch)
498
 
        self.mb_branch_update.set_sensitive(not notbranch)
499
 
        self.mb_branch_revert.set_sensitive(not notbranch)
500
 
        self.mb_branch_merge.set_sensitive(not notbranch)
501
 
        self.mb_branch_commit.set_sensitive(not notbranch)
502
 
        self.mb_branch_tags.set_sensitive(not notbranch)
503
 
        self.mb_branch_status.set_sensitive(not notbranch)
504
 
        self.mb_branch_missingrevisions.set_sensitive(not notbranch)
505
 
        self.mb_branch_conflicts.set_sensitive(not notbranch)
506
 
        self.mb_statistics.set_sensitive(not notbranch)
507
 
        self.mb_statistics_differences.set_sensitive(not notbranch)
508
 
        self.mb_file_add.set_sensitive(not notbranch)
509
 
        self.mb_file_remove.set_sensitive(not notbranch)
510
 
        self.mb_file_mkdir.set_sensitive(not notbranch)
511
 
        self.mb_file_rename.set_sensitive(not notbranch)
512
 
        self.mb_file_move.set_sensitive(not notbranch)
513
 
        self.mb_file_annotate.set_sensitive(not notbranch)
514
 
        self.tb_diff.set_sensitive(not notbranch)
515
 
        self.tb_log.set_sensitive(not notbranch)
516
 
        self.tb_commit.set_sensitive(not notbranch)
517
 
        self.tb_pull.set_sensitive(not notbranch)
518
 
        self.tb_push.set_sensitive(not notbranch)
519
 
        self.tb_update.set_sensitive(not notbranch)
520
 
    
521
 
    def set_view_to_remotebranch(self):
522
 
        """ Change the sensitivity of gui items to reflect the fact that the branch is remote"""
523
 
        self.mb_file_add.set_sensitive(False)
524
 
        self.mb_file_remove.set_sensitive(False)
525
 
        self.mb_file_mkdir.set_sensitive(False)
526
 
        self.mb_file_rename.set_sensitive(False)
527
 
        self.mb_file_move.set_sensitive(False)
528
 
        self.mb_file_annotate.set_sensitive(False)
529
 
        self.mb_branch_initialize.set_sensitive(False)
530
 
        self.mb_branch_get.set_sensitive(True)
531
 
        self.mb_branch_checkout.set_sensitive(True)
532
 
        self.mb_branch_pull.set_sensitive(False)
533
 
        self.mb_branch_push.set_sensitive(False)
534
 
        self.mb_branch_update.set_sensitive(False)
535
 
        self.mb_branch_revert.set_sensitive(False)
536
 
        self.mb_branch_merge.set_sensitive(False)
537
 
        self.mb_branch_commit.set_sensitive(False)
538
 
        self.mb_branch_tags.set_sensitive(True)
539
 
        self.mb_branch_status.set_sensitive(False)
540
 
        self.mb_branch_missingrevisions.set_sensitive(False)
541
 
        self.mb_branch_conflicts.set_sensitive(False)
542
 
        self.mb_statistics.set_sensitive(True)
543
 
        self.mb_statistics_differences.set_sensitive(False)
544
 
        self.tb_diff.set_sensitive(False)
545
 
        self.tb_log.set_sensitive(True)
546
 
        self.tb_commit.set_sensitive(False)
547
 
        self.tb_pull.set_sensitive(False)
548
 
        self.tb_push.set_sensitive(False)
549
 
        self.tb_update.set_sensitive(False)
550
 
    
551
 
    def set_location_status(self, stock_id, allowPopup=False):
552
 
        self.location_status.destroy()
553
 
        if allowPopup:
554
 
            self.location_status = gtk.Button()
555
 
            self.location_status.set_relief(gtk.RELIEF_NONE)
556
 
            image = gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_BUTTON)
557
 
            image.show()
558
 
            self.location_status.add(image)
559
 
        else:
560
 
            self.location_status = gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_BUTTON)
561
 
        self.locationbar.pack_start(self.location_status, False, False, 0)
562
 
        if sys.platform == 'win32':
563
 
            self.locationbar.reorder_child(self.location_status, 2)
564
 
        else:
565
 
            self.locationbar.reorder_child(self.location_status, 1)
566
 
        self.location_status.show()