/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/__init__.py

  • Committer: Jelmer Vernooij
  • Date: 2006-09-30 10:21:43 UTC
  • Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/__init__.py
 
1
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import os
 
18
import sys
 
19
 
 
20
try:
 
21
    import pygtk
 
22
    pygtk.require("2.0")
 
23
except:
 
24
    pass
 
25
 
 
26
import gtk
 
27
import gtk.gdk
 
28
import gtk.glade
 
29
 
 
30
from bzrlib.branch import Branch
 
31
import bzrlib.errors as errors
 
32
from bzrlib.workingtree import WorkingTree
 
33
 
 
34
# Olive GTK UI version
 
35
__version__ = '0.11.0'
 
36
 
 
37
# Load the glade file
 
38
if sys.platform == 'win32':
 
39
    gladefile = os.path.dirname(sys.executable) + "/share/olive/olive.glade"
 
40
else:
 
41
    gladefile = "/usr/share/olive/olive.glade"
 
42
 
 
43
if not os.path.exists(gladefile):
 
44
    # Load from current directory if not installed
 
45
    gladefile = "olive.glade"
 
46
    # Check again
 
47
    if not os.path.exists(gladefile):
 
48
        # Fail
 
49
        print _('Glade file cannot be found.')
 
50
        sys.exit(1)
 
51
 
 
52
from dialog import error_dialog, info_dialog
 
53
 
 
54
class OliveGtk:
 
55
    """ The main Olive GTK frontend class. This is called when launching the
 
56
    program. """
 
57
    
 
58
    def __init__(self):
 
59
        self.toplevel = gtk.glade.XML(gladefile, 'window_main', 'olive-gtk')
 
60
        
 
61
        self.window = self.toplevel.get_widget('window_main')
 
62
        
 
63
        self.pref = OlivePreferences()
 
64
 
 
65
        # Initialize the statusbar
 
66
        self.statusbar = self.toplevel.get_widget('statusbar')
 
67
        self.context_id = self.statusbar.get_context_id('olive')
 
68
        
 
69
        # Get the main window
 
70
        self.window_main = self.toplevel.get_widget('window_main')
 
71
        # Get the HPaned
 
72
        self.hpaned_main = self.toplevel.get_widget('hpaned_main')
 
73
        # Get the TreeViews
 
74
        self.treeview_left = self.toplevel.get_widget('treeview_left')
 
75
        self.treeview_right = self.toplevel.get_widget('treeview_right')
 
76
        # Get some important menu items
 
77
        self.menuitem_add_files = self.toplevel.get_widget('menuitem_add_files')
 
78
        self.menuitem_remove_files = self.toplevel.get_widget('menuitem_remove_file')
 
79
        self.menuitem_file_make_directory = self.toplevel.get_widget('menuitem_file_make_directory')
 
80
        self.menuitem_file_rename = self.toplevel.get_widget('menuitem_file_rename')
 
81
        self.menuitem_file_move = self.toplevel.get_widget('menuitem_file_move')
 
82
        self.menuitem_view_show_hidden_files = self.toplevel.get_widget('menuitem_view_show_hidden_files')
 
83
        self.menuitem_branch = self.toplevel.get_widget('menuitem_branch')
 
84
        self.menuitem_branch_init = self.toplevel.get_widget('menuitem_branch_initialize')
 
85
        self.menuitem_branch_get = self.toplevel.get_widget('menuitem_branch_get')
 
86
        self.menuitem_branch_checkout = self.toplevel.get_widget('menuitem_branch_checkout')
 
87
        self.menuitem_branch_pull = self.toplevel.get_widget('menuitem_branch_pull')
 
88
        self.menuitem_branch_push = self.toplevel.get_widget('menuitem_branch_push')
 
89
        self.menuitem_branch_commit = self.toplevel.get_widget('menuitem_branch_commit')
 
90
        self.menuitem_branch_status = self.toplevel.get_widget('menuitem_branch_status')
 
91
        self.menuitem_branch_missing = self.toplevel.get_widget('menuitem_branch_missing_revisions')
 
92
        self.menuitem_stats = self.toplevel.get_widget('menuitem_stats')
 
93
        self.menuitem_stats_diff = self.toplevel.get_widget('menuitem_stats_diff')
 
94
        self.menuitem_stats_log = self.toplevel.get_widget('menuitem_stats_log')
 
95
        # Get some toolbuttons
 
96
        #self.menutoolbutton_diff = self.toplevel.get_widget('menutoolbutton_diff')
 
97
        self.toolbutton_diff = self.toplevel.get_widget('toolbutton_diff')
 
98
        self.toolbutton_log = self.toplevel.get_widget('toolbutton_log')
 
99
        self.toolbutton_commit = self.toplevel.get_widget('toolbutton_commit')
 
100
        self.toolbutton_pull = self.toplevel.get_widget('toolbutton_pull')
 
101
        self.toolbutton_push = self.toplevel.get_widget('toolbutton_push')
 
102
        # Get the drive selector
 
103
        self.combobox_drive = gtk.combo_box_new_text()
 
104
        self.combobox_drive.connect("changed", self._refresh_drives)
 
105
        
 
106
        self.vbox_main_right = self.toplevel.get_widget('vbox_main_right')
 
107
 
 
108
        
 
109
        # Dictionary for signal_autoconnect
 
110
        dic = { "on_window_main_destroy": gtk.main_quit,
 
111
                "on_window_main_delete_event": self.on_window_main_delete_event,
 
112
                "on_quit_activate": self.on_window_main_delete_event,
 
113
                "on_about_activate": self.on_about_activate,
 
114
                "on_menuitem_add_files_activate": self.on_menuitem_add_files_activate,
 
115
                "on_menuitem_remove_file_activate": self.on_menuitem_remove_file_activate,
 
116
                "on_menuitem_file_make_directory_activate": self.on_menuitem_file_make_directory_activate,
 
117
                "on_menuitem_file_move_activate": self.on_menuitem_file_move_activate,
 
118
                "on_menuitem_file_rename_activate": self.on_menuitem_file_rename_activate,
 
119
                "on_menuitem_view_show_hidden_files_activate": self.on_menuitem_view_show_hidden_files_activate,
 
120
                "on_menuitem_view_refresh_activate": self.on_menuitem_view_refresh_activate,
 
121
                "on_menuitem_branch_initialize_activate": self.on_menuitem_branch_initialize_activate,
 
122
                "on_menuitem_branch_get_activate": self.on_menuitem_branch_get_activate,
 
123
                "on_menuitem_branch_checkout_activate": self.on_menuitem_branch_checkout_activate,
 
124
                "on_menuitem_branch_commit_activate": self.on_menuitem_branch_commit_activate,
 
125
                "on_menuitem_branch_push_activate": self.on_menuitem_branch_push_activate,
 
126
                "on_menuitem_branch_pull_activate": self.on_menuitem_branch_pull_activate,
 
127
                "on_menuitem_branch_status_activate": self.on_menuitem_branch_status_activate,
 
128
                "on_menuitem_branch_missing_revisions_activate": self.on_menuitem_branch_missing_revisions_activate,
 
129
                "on_menuitem_stats_diff_activate": self.on_menuitem_stats_diff_activate,
 
130
                "on_menuitem_stats_log_activate": self.on_menuitem_stats_log_activate,
 
131
                "on_menuitem_stats_infos_activate": self.on_menuitem_stats_infos_activate,
 
132
                "on_toolbutton_refresh_clicked": self.on_menuitem_view_refresh_activate,
 
133
                "on_toolbutton_log_clicked": self.on_menuitem_stats_log_activate,
 
134
                #"on_menutoolbutton_diff_clicked": self.on_menuitem_stats_diff_activate,
 
135
                "on_toolbutton_diff_clicked": self.on_menuitem_stats_diff_activate,
 
136
                "on_toolbutton_commit_clicked": self.on_menuitem_branch_commit_activate,
 
137
                "on_toolbutton_pull_clicked": self.on_menuitem_branch_pull_activate,
 
138
                "on_toolbutton_push_clicked": self.on_menuitem_branch_push_activate,
 
139
                "on_treeview_right_button_press_event": self.on_treeview_right_button_press_event,
 
140
                "on_treeview_right_row_activated": self.on_treeview_right_row_activated,
 
141
                "on_treeview_left_button_press_event": self.on_treeview_left_button_press_event,
 
142
                "on_treeview_left_row_activated": self.on_treeview_left_row_activated }
 
143
        
 
144
        # Connect the signals to the handlers
 
145
        self.toplevel.signal_autoconnect(dic)
 
146
        
 
147
        # Apply window size and position
 
148
        width = self.pref.get_preference('window_width', 'int')
 
149
        height = self.pref.get_preference('window_height', 'int')
 
150
        self.window.resize(width, height)
 
151
        x = self.pref.get_preference('window_x', 'int')
 
152
        y = self.pref.get_preference('window_y', 'int')
 
153
        self.window.move(x, y)
 
154
        # Apply paned position
 
155
        pos = self.pref.get_preference('paned_position', 'int')
 
156
        self.hpaned_main.set_position(pos)
 
157
        
 
158
        # Apply menu to the toolbutton
 
159
        #menubutton = self.toplevel.get_widget('menutoolbutton_diff')
 
160
        #menubutton.set_menu(handler.menu.toolbar_diff)
 
161
        
 
162
        # Now we can show the window
 
163
        self.window.show()
 
164
        
 
165
        # Show drive selector if under Win32
 
166
        if sys.platform == 'win32':
 
167
            self.vbox_main_right.pack_start(self.combobox_drive, False, True, 0)
 
168
            self.vbox_main_right.reorder_child(self.combobox_drive, 0)
 
169
            self.combobox_drive.show()
 
170
            self.gen_hard_selector()
 
171
        
 
172
        self._load_left()
 
173
 
 
174
        # Apply menu state
 
175
        self.menuitem_view_show_hidden_files.set_active(self.pref.get_preference('dotted_files', 'bool'))
 
176
 
 
177
        self.set_path(os.getcwd())
 
178
        self._load_right()
 
179
 
 
180
    def set_path(self, path):
 
181
        self.path = path
 
182
        self.notbranch = False
 
183
        try:
 
184
            self.wt, self.wtpath = WorkingTree.open_containing(self.path)
 
185
        except errors.NotBranchError:
 
186
            self.notbranch = True
 
187
 
 
188
    def get_path(self):
 
189
        return self.path
 
190
   
 
191
    def on_about_activate(self, widget):
 
192
        from dialog import about
 
193
        about()
 
194
        
 
195
    def on_menuitem_add_files_activate(self, widget):
 
196
        """ Add file(s)... menu handler. """
 
197
        from add import OliveAdd
 
198
        add = OliveAdd(self.wt, self.wtpath, self.get_selected_right())
 
199
        add.display()
 
200
    
 
201
    def on_menuitem_branch_get_activate(self, widget):
 
202
        """ Branch/Get... menu handler. """
 
203
        from branch import OliveBranch
 
204
        branch = OliveBranch()
 
205
        branch.display()
 
206
    
 
207
    def on_menuitem_branch_checkout_activate(self, widget):
 
208
        """ Branch/Checkout... menu handler. """
 
209
        from checkout import OliveCheckout
 
210
        checkout = OliveCheckout()
 
211
        checkout.display()
 
212
    
 
213
    def on_menuitem_branch_commit_activate(self, widget):
 
214
        """ Branch/Commit... menu handler. """
 
215
        from commit import OliveCommit
 
216
        commit = OliveCommit(self.wt, self.wtpath)
 
217
        commit.display()
 
218
    
 
219
    def on_menuitem_branch_missing_revisions_activate(self, widget):
 
220
        """ Branch/Missing revisions menu handler. """
 
221
        local_branch = self.wt.branch
 
222
        
 
223
        other_branch = local_branch.get_parent()
 
224
        if other_branch is None:
 
225
            error_dialog(_('Parent location is unknown'),
 
226
                                     _('Cannot determine missing revisions if no parent location is known.'))
 
227
            return
 
228
        
 
229
        remote_branch = Branch.open(other_branch)
 
230
        
 
231
        if remote_branch.base == local_branch.base:
 
232
            remote_branch = local_branch
 
233
 
 
234
        ret = len(local_branch.missing_revisions(remote_branch))
 
235
 
 
236
        if ret > 0:
 
237
            info_dialog(_('There are missing revisions'),
 
238
                                    _('%d revision(s) missing.') % ret)
 
239
        else:
 
240
            info_dialog(_('Local branch up to date'),
 
241
                                    _('There are no missing revisions.'))
 
242
 
 
243
    def on_menuitem_branch_pull_activate(self, widget):
 
244
        """ Branch/Pull menu handler. """
 
245
        branch_to = self.wt.branch
 
246
 
 
247
        location = branch_to.get_parent()
 
248
        if location is None:
 
249
            error_dialog(_('Parent location is unknown'),
 
250
                                     _('Pulling is not possible until there is a parent location.'))
 
251
            return
 
252
 
 
253
        try:
 
254
            branch_from = Branch.open(location)
 
255
        except errors.NotBranchError:
 
256
            error_dialog(_('Directory is not a branch'),
 
257
                                     _('You can perform this action only in a branch.'))
 
258
 
 
259
        if branch_to.get_parent() is None:
 
260
            branch_to.set_parent(branch_from.base)
 
261
 
 
262
        #old_rh = branch_to.revision_history()
 
263
        #if tree_to is not None:
 
264
        #    tree_to.pull(branch_from)
 
265
        #else:
 
266
        #    branch_to.pull(branch_from)
 
267
        branch_to.pull(branch_from)
 
268
        
 
269
        # TODO: get the number of pulled revisions
 
270
        ret = 0
 
271
        
 
272
        info_dialog(_('Pull successful'), _('%d revision(s) pulled.') % ret)
 
273
    
 
274
    def on_menuitem_branch_push_activate(self, widget):
 
275
        """ Branch/Push... menu handler. """
 
276
        from push import OlivePush
 
277
        push = OlivePush(self.wt.branch)
 
278
        push.display()
 
279
    
 
280
    def on_menuitem_branch_status_activate(self, widget):
 
281
        """ Branch/Status... menu handler. """
 
282
        from status import OliveStatus
 
283
        status = OliveStatus(self.wt, self.wtpath)
 
284
        status.display()
 
285
    
 
286
    def on_menuitem_branch_initialize_activate(self, widget):
 
287
        """ Initialize current directory. """
 
288
        import bzrlib.bzrdir as bzrdir
 
289
        
 
290
        try:
 
291
            if not os.path.exists(self.path):
 
292
                os.mkdir(self.path)
 
293
     
 
294
            try:
 
295
                existing_bzrdir = bzrdir.BzrDir.open(self.path)
 
296
            except errors.NotBranchError:
 
297
                bzrdir.BzrDir.create_branch_convenience(self.path)
 
298
            else:
 
299
                if existing_bzrdir.has_branch():
 
300
                    if existing_bzrdir.has_workingtree():
 
301
                        raise errors.AlreadyBranchError(self.path)
 
302
                    else:
 
303
                        raise errors.BranchExistsWithoutWorkingTree(self.path)
 
304
                else:
 
305
                    existing_bzrdir.create_branch()
 
306
                    existing_bzrdir.create_workingtree()
 
307
        except errors.AlreadyBranchError, errmsg:
 
308
            error_dialog(_('Directory is already a branch'),
 
309
                                     _('The current directory (%s) is already a branch.\nYou can start using it, or initialize another directory.') % errmsg)
 
310
        except errors.BranchExistsWithoutWorkingTree, errmsg:
 
311
            error_dialog(_('Branch without a working tree'),
 
312
                                     _('The current directory (%s)\nis a branch without a working tree.') % errmsg)
 
313
        else:
 
314
            info_dialog(_('Initialize successful'),
 
315
                                    _('Directory successfully initialized.'))
 
316
            self.refresh_right()
 
317
        
 
318
    def on_menuitem_file_make_directory_activate(self, widget):
 
319
        """ File/Make directory... menu handler. """
 
320
        from mkdir import OliveMkdir
 
321
        mkdir = OliveMkdir(self.wt, self.wtpath)
 
322
        mkdir.display()
 
323
    
 
324
    def on_menuitem_file_move_activate(self, widget):
 
325
        """ File/Move... menu handler. """
 
326
        from move import OliveMove
 
327
        move = OliveMove(self.wt, self.wtpath, self.get_selected_right())
 
328
        move.display()
 
329
    
 
330
    def on_menuitem_file_rename_activate(self, widget):
 
331
        """ File/Rename... menu handler. """
 
332
        from rename import OliveRename
 
333
        rename = OliveRename(self.wt, self.wtpath, self.get_selected_right())
 
334
        rename.display()
 
335
 
 
336
    def on_menuitem_remove_file_activate(self, widget):
 
337
        """ Remove (unversion) selected file. """
 
338
        from remove import OliveRemove
 
339
        remove = OliveRemove(self.wt, self.wtpath, self.get_selected_right())
 
340
        remove.display()
 
341
    
 
342
    def on_menuitem_stats_diff_activate(self, widget):
 
343
        """ Statistics/Differences... menu handler. """
 
344
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
 
345
        window = DiffWindow()
 
346
        parent_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
 
347
        window.set_diff(self.wt.branch.nick, self.wt, parent_tree)
 
348
        window.show()
 
349
    
 
350
    def on_menuitem_stats_infos_activate(self, widget):
 
351
        """ Statistics/Informations... menu handler. """
 
352
        from info import OliveInfo
 
353
        info = OliveInfo(self.wt)
 
354
        info.display()
 
355
    
 
356
    def on_menuitem_stats_log_activate(self, widget):
 
357
        """ Statistics/Log... menu handler. """
 
358
        from bzrlib.plugins.gtk.viz.branchwin import BranchWindow
 
359
        window = BranchWindow()
 
360
        window.set_branch(self.wt.branch, self.wt.branch.last_revision(), None)
 
361
        window.show()
 
362
    
 
363
    def on_menuitem_view_refresh_activate(self, widget):
 
364
        """ View/Refresh menu handler. """
 
365
        # Refresh the left pane
 
366
        self.refresh_left()
 
367
        # Refresh the right pane
 
368
        self.refresh_right()
 
369
   
 
370
    def on_menuitem_view_show_hidden_files_activate(self, widget):
 
371
        """ View/Show hidden files menu handler. """
 
372
        self.pref.set_preference('dotted_files', widget.get_active())
 
373
 
 
374
    def on_treeview_left_button_press_event(self, widget, event):
 
375
        """ Occurs when somebody right-clicks in the bookmark list. """
 
376
        if event.button == 3:
 
377
            # Don't show context with nothing selected
 
378
            if self.get_selected_left() == None:
 
379
                return
 
380
 
 
381
            # Create a menu
 
382
            from menu import OliveMenu
 
383
            menu = OliveMenu(self.get_path(), self.get_selected_left())
 
384
            
 
385
            menu.left_context_menu().popup(None, None, None, 0,
 
386
                                           event.time)
 
387
            
 
388
            # Bookmarks might have changed
 
389
            self.pref.read()
 
390
        
 
391
    def on_treeview_left_row_activated(self, treeview, path, view_column):
 
392
        """ Occurs when somebody double-clicks or enters an item in the
 
393
        bookmark list. """
 
394
 
 
395
        newdir = self.get_selected_left()
 
396
        if newdir == None:
 
397
            return
 
398
 
 
399
        self.set_path(newdir)
 
400
        self.refresh_right()
 
401
    
 
402
    def on_treeview_right_button_press_event(self, widget, event):
 
403
        """ Occurs when somebody right-clicks in the file list. """
 
404
        if event.button == 3:
 
405
            # Create a menu
 
406
            from menu import OliveMenu
 
407
            menu = OliveMenu(self.get_path(), self.get_selected_right())
 
408
            # get the menu items
 
409
            m_add = menu.ui.get_widget('/context_right/add')
 
410
            m_remove = menu.ui.get_widget('/context_right/remove')
 
411
            m_commit = menu.ui.get_widget('/context_right/commit')
 
412
            m_diff = menu.ui.get_widget('/context_right/diff')
 
413
            # check if we're in a branch
 
414
            try:
 
415
                from bzrlib.branch import Branch
 
416
                Branch.open_containing(self.get_path())
 
417
                m_add.set_sensitive(True)
 
418
                m_remove.set_sensitive(True)
 
419
                m_commit.set_sensitive(True)
 
420
                m_diff.set_sensitive(True)
 
421
            except errors.NotBranchError:
 
422
                m_add.set_sensitive(False)
 
423
                m_remove.set_sensitive(False)
 
424
                m_commit.set_sensitive(False)
 
425
                m_diff.set_sensitive(False)
 
426
            menu.right_context_menu().popup(None, None, None, 0,
 
427
                                            event.time)
 
428
        
 
429
    def on_treeview_right_row_activated(self, treeview, path, view_column):
 
430
        """ Occurs when somebody double-clicks or enters an item in the
 
431
        file list. """
 
432
        import os.path
 
433
        
 
434
        from launch import launch
 
435
        
 
436
        newdir = self.get_selected_right()
 
437
        
 
438
        if newdir == '..':
 
439
            self.set_path(os.path.split(self.get_path())[0])
 
440
        else:
 
441
            fullpath = self.get_path() + os.sep + newdir
 
442
            if os.path.isdir(fullpath):
 
443
                # selected item is an existant directory
 
444
                self.set_path(fullpath)
 
445
            else:
 
446
                launch(fullpath) 
 
447
        
 
448
        self.refresh_right()
 
449
    
 
450
    def on_window_main_delete_event(self, widget, event=None):
 
451
        """ Do some stuff before exiting. """
 
452
        width, height = self.window_main.get_size()
 
453
        self.pref.set_preference('window_width', width)
 
454
        self.pref.set_preference('window_height', height)
 
455
        x, y = self.window_main.get_position()
 
456
        self.pref.set_preference('window_x', x)
 
457
        self.pref.set_preference('window_y', y)
 
458
        self.pref.set_preference('paned_position',
 
459
                                      self.hpaned_main.get_position())
 
460
        
 
461
        self.pref.write()
 
462
        self.window_main.destroy()
 
463
        
 
464
    def _load_left(self):
 
465
        """ Load data into the left panel. (Bookmarks) """
 
466
        # Create TreeStore
 
467
        treestore = gtk.TreeStore(str, str)
 
468
        
 
469
        # Get bookmarks
 
470
        bookmarks = self.pref.get_bookmarks()
 
471
        
 
472
        # Add them to the TreeStore
 
473
        titer = treestore.append(None, [_('Bookmarks'), None])
 
474
        for item in bookmarks:
 
475
            title = self.pref.get_bookmark_title(item)
 
476
            treestore.append(titer, [title, item])
 
477
        
 
478
        # Create the column and add it to the TreeView
 
479
        self.treeview_left.set_model(treestore)
 
480
        tvcolumn_bookmark = gtk.TreeViewColumn(_('Bookmark'))
 
481
        self.treeview_left.append_column(tvcolumn_bookmark)
 
482
        
 
483
        # Set up the cells
 
484
        cell = gtk.CellRendererText()
 
485
        tvcolumn_bookmark.pack_start(cell, True)
 
486
        tvcolumn_bookmark.add_attribute(cell, 'text', 0)
 
487
        
 
488
        # Expand the tree
 
489
        self.treeview_left.expand_all()
 
490
 
 
491
    def _load_right(self):
 
492
        """ Load data into the right panel. (Filelist) """
 
493
        # Create ListStore
 
494
        liststore = gtk.ListStore(str, str, str)
 
495
        
 
496
        dirs = ['..']
 
497
        files = []
 
498
        
 
499
        # Fill the appropriate lists
 
500
        dotted_files = self.pref.get_preference('dotted_files', 'bool')
 
501
        for item in os.listdir(self.path):
 
502
            if not dotted_files and item[0] == '.':
 
503
                continue
 
504
            if os.path.isdir(self.path + os.sep + item):
 
505
                dirs.append(item)
 
506
            else:
 
507
                files.append(item)
 
508
            
 
509
        # Sort'em
 
510
        dirs.sort()
 
511
        files.sort()
 
512
        
 
513
        if not self.notbranch:
 
514
            branch = self.wt.branch
 
515
            tree2 = self.wt.branch.repository.revision_tree(branch.last_revision())
 
516
        
 
517
            delta = self.wt.changes_from(tree2, want_unchanged=True)
 
518
        
 
519
        # Add'em to the ListStore
 
520
        for item in dirs:    
 
521
            liststore.append([gtk.STOCK_DIRECTORY, item, ''])
 
522
        for item in files:
 
523
            status = 'unknown'
 
524
            if not self.notbranch:
 
525
                filename = self.wt.relpath(self.path + os.sep + item)
 
526
                
 
527
                for rpath, id, kind, text_modified, meta_modified in delta.renamed:
 
528
                    if rpath == filename:
 
529
                        status = 'renamed'
 
530
                for rpath, id, kind in delta.added:
 
531
                    if rpath == filename:
 
532
                        status = 'added'
 
533
                for rpath, id, kind in delta.removed:
 
534
                    if rpath == filename:
 
535
                        status = 'removed'
 
536
                for rpath, id, kind, text_modified, meta_modified in delta.modified:
 
537
                    if rpath == filename:
 
538
                        status = 'modified'
 
539
                for rpath, id, kind in delta.unchanged:
 
540
                    if rpath == filename:
 
541
                        status = 'unchanged'
 
542
            
 
543
            #try:
 
544
            #    status = fileops.status(path + os.sep + item)
 
545
            #except errors.PermissionDenied:
 
546
            #    continue
 
547
            
 
548
            if status == 'renamed':
 
549
                st = _('renamed')
 
550
            elif status == 'removed':
 
551
                st = _('removed')
 
552
            elif status == 'added':
 
553
                st = _('added')
 
554
            elif status == 'modified':
 
555
                st = _('modified')
 
556
            elif status == 'unchanged':
 
557
                st = _('unchanged')
 
558
            else:
 
559
                st = _('unknown')
 
560
            liststore.append([gtk.STOCK_FILE, item, st])
 
561
        
 
562
        # Create the columns and add them to the TreeView
 
563
        self.treeview_right.set_model(liststore)
 
564
        tvcolumn_filename = gtk.TreeViewColumn(_('Filename'))
 
565
        tvcolumn_status = gtk.TreeViewColumn(_('Status'))
 
566
        self.treeview_right.append_column(tvcolumn_filename)
 
567
        self.treeview_right.append_column(tvcolumn_status)
 
568
        
 
569
        # Set up the cells
 
570
        cellpb = gtk.CellRendererPixbuf()
 
571
        cell = gtk.CellRendererText()
 
572
        tvcolumn_filename.pack_start(cellpb, False)
 
573
        tvcolumn_filename.pack_start(cell, True)
 
574
        tvcolumn_filename.set_attributes(cellpb, stock_id=0)
 
575
        tvcolumn_filename.add_attribute(cell, 'text', 1)
 
576
        tvcolumn_status.pack_start(cell, True)
 
577
        tvcolumn_status.add_attribute(cell, 'text', 2)
 
578
 
 
579
        self.menuitem_branch_init.set_sensitive(self.notbranch)
 
580
        # Check if current directory is a branch
 
581
        self.menuitem_branch_get.set_sensitive(not self.notbranch)
 
582
        self.menuitem_branch_checkout.set_sensitive(not self.notbranch)
 
583
        self.menuitem_branch_pull.set_sensitive(not self.notbranch)
 
584
        self.menuitem_branch_push.set_sensitive(not self.notbranch)
 
585
        self.menuitem_branch_commit.set_sensitive(not self.notbranch)
 
586
        self.menuitem_branch_status.set_sensitive(not self.notbranch)
 
587
        self.menuitem_branch_missing.set_sensitive(not self.notbranch)
 
588
        self.menuitem_stats.set_sensitive(not self.notbranch)
 
589
        self.menuitem_add_files.set_sensitive(not self.notbranch)
 
590
        self.menuitem_remove_files.set_sensitive(not self.notbranch)
 
591
        self.menuitem_file_make_directory.set_sensitive(not self.notbranch)
 
592
        self.menuitem_file_rename.set_sensitive(not self.notbranch)
 
593
        self.menuitem_file_move.set_sensitive(not self.notbranch)
 
594
        #self.menutoolbutton_diff.set_sensitive(True)
 
595
        self.toolbutton_diff.set_sensitive(not self.notbranch)
 
596
        self.toolbutton_log.set_sensitive(not self.notbranch)
 
597
        self.toolbutton_commit.set_sensitive(not self.notbranch)
 
598
        self.toolbutton_pull.set_sensitive(not self.notbranch)
 
599
        self.toolbutton_push.set_sensitive(not self.notbranch)
 
600
        
 
601
    def get_selected_right(self):
 
602
        """ Get the selected filename. """
 
603
        treeselection = self.treeview_right.get_selection()
 
604
        (model, iter) = treeselection.get_selected()
 
605
        
 
606
        if iter is None:
 
607
            return None
 
608
        else:
 
609
            return model.get_value(iter, 1)
 
610
    
 
611
    def get_selected_left(self):
 
612
        """ Get the selected bookmark. """
 
613
        treeselection = self.treeview_left.get_selection()
 
614
        (model, iter) = treeselection.get_selected()
 
615
        
 
616
        if iter is None:
 
617
            return None
 
618
        else:
 
619
            return model.get_value(iter, 1)
 
620
 
 
621
    def set_statusbar(self, message):
 
622
        """ Set the statusbar message. """
 
623
        self.statusbar.push(self.context_id, message)
 
624
    
 
625
    def clear_statusbar(self):
 
626
        """ Clean the last message from the statusbar. """
 
627
        self.statusbar.pop(self.context_id)
 
628
    
 
629
    def refresh_left(self):
 
630
        """ Refresh the bookmark list. """
 
631
        
 
632
        # Get TreeStore and clear it
 
633
        treestore = self.treeview_left.get_model()
 
634
        treestore.clear()
 
635
 
 
636
        # Get bookmarks
 
637
        bookmarks = self.pref.get_bookmarks()
 
638
 
 
639
        # Add them to the TreeStore
 
640
        titer = treestore.append(None, [_('Bookmarks'), None])
 
641
        for item in bookmarks:
 
642
            title = self.pref.get_bookmark_title(item)
 
643
            treestore.append(titer, [title, item])
 
644
 
 
645
        # Add the TreeStore to the TreeView
 
646
        self.treeview_left.set_model(treestore)
 
647
 
 
648
        # Expand the tree
 
649
        self.treeview_left.expand_all()
 
650
 
 
651
    def refresh_right(self, path=None):
 
652
        """ Refresh the file list. """
 
653
        from bzrlib.workingtree import WorkingTree
 
654
 
 
655
        if path is None:
 
656
            path = self.get_path()
 
657
 
 
658
        # A workaround for double-clicking Bookmarks
 
659
        if not os.path.exists(path):
 
660
            return
 
661
 
 
662
        # Get ListStore and clear it
 
663
        liststore = self.treeview_right.get_model()
 
664
        liststore.clear()
 
665
 
 
666
        dirs = ['..']
 
667
        files = []
 
668
 
 
669
        # Fill the appropriate lists
 
670
        dotted_files = self.pref.get_preference('dotted_files', 'bool')
 
671
        for item in os.listdir(path):
 
672
            if not dotted_files and item[0] == '.':
 
673
                continue
 
674
            if os.path.isdir(path + os.sep + item):
 
675
                dirs.append(item)
 
676
            else:
 
677
                files.append(item)
 
678
 
 
679
        # Sort'em
 
680
        dirs.sort()
 
681
        files.sort()
 
682
        
 
683
        # Try to open the working tree
 
684
        notbranch = False
 
685
        try:
 
686
            tree1 = WorkingTree.open_containing(path)[0]
 
687
        except errors.NotBranchError:
 
688
            notbranch = True
 
689
        except errors.PermissionDenied:
 
690
            print "DEBUG: permission denied."
 
691
        
 
692
        if not notbranch:
 
693
            branch = tree1.branch
 
694
            tree2 = tree1.branch.repository.revision_tree(branch.last_revision())
 
695
        
 
696
            delta = tree1.changes_from(tree2, want_unchanged=True)
 
697
 
 
698
        # Add'em to the ListStore
 
699
        for item in dirs:
 
700
            liststore.append([gtk.STOCK_DIRECTORY, item, ''])
 
701
        for item in files:
 
702
            status = 'unknown'
 
703
            if not notbranch:
 
704
                filename = tree1.relpath(path + os.sep + item)
 
705
                
 
706
                for rpath, id, kind, text_modified, meta_modified in delta.renamed:
 
707
                    if rpath == filename:
 
708
                        status = 'renamed'
 
709
                for rpath, id, kind in delta.added:
 
710
                    if rpath == filename:
 
711
                        status = 'added'
 
712
                for rpath, id, kind, text_modified, meta_modified in delta.removed:
 
713
                    if rpath == filename:
 
714
                        status = 'removed'
 
715
                for rpath, id, kind, text_modified, meta_modified in delta.modified:
 
716
                    if rpath == filename:
 
717
                        status = 'modified'
 
718
                for rpath, id, kind in delta.unchanged:
 
719
                    if rpath == filename:
 
720
                        status = 'unchanged'
 
721
            
 
722
            #try:
 
723
            #    status = fileops.status(path + os.sep + item)
 
724
            #except errors.PermissionDenied:
 
725
            #    continue
 
726
 
 
727
            if status == 'renamed':
 
728
                st = _('renamed')
 
729
            elif status == 'removed':
 
730
                st = _('removed')
 
731
            elif status == 'added':
 
732
                st = _('added')
 
733
            elif status == 'modified':
 
734
                st = _('modified')
 
735
            elif status == 'unchanged':
 
736
                st = _('unchanged')
 
737
            else:
 
738
                st = _('unknown')
 
739
            liststore.append([gtk.STOCK_FILE, item, st])
 
740
 
 
741
        # Add the ListStore to the TreeView
 
742
        self.treeview_right.set_model(liststore)
 
743
 
 
744
    def _harddisks(self):
 
745
        """ Returns hard drive letters under Win32. """
 
746
        try:
 
747
            import win32file
 
748
            import string
 
749
        except ImportError:
 
750
            if sys.platform == 'win32':
 
751
                print "pyWin32 modules needed to run Olive on Win32."
 
752
                sys.exit(1)
 
753
            else:
 
754
                pass
 
755
        
 
756
        driveletters = []
 
757
        for drive in string.ascii_uppercase:
 
758
            if win32file.GetDriveType(drive+':') == win32file.DRIVE_FIXED:
 
759
                driveletters.append(drive+':')
 
760
        return driveletters
 
761
    
 
762
    def gen_hard_selector(self):
 
763
        """ Generate the hard drive selector under Win32. """
 
764
        drives = self._harddisks()
 
765
        for drive in drives:
 
766
            self.combobox_drive.append_text(drive)
 
767
    
 
768
    def _refresh_drives(self, combobox):
 
769
        model = combobox.get_model()
 
770
        active = combobox.get_active()
 
771
        if active >= 0:
 
772
            drive = model[active][0]
 
773
            self.refresh_right(drive + '\\')
 
774
 
 
775
import ConfigParser
 
776
 
 
777
class OlivePreferences:
 
778
    """ A class which handles Olive's preferences. """
 
779
    def __init__(self):
 
780
        """ Initialize the Preferences class. """
 
781
        # Some default options
 
782
        self.defaults = { 'strict_commit' : False,
 
783
                          'dotted_files'  : False,
 
784
                          'window_width'  : 700,
 
785
                          'window_height' : 400,
 
786
                          'window_x'      : 40,
 
787
                          'window_y'      : 40,
 
788
                          'paned_position': 200 }
 
789
 
 
790
        # Create a config parser object
 
791
        self.config = ConfigParser.RawConfigParser()
 
792
        
 
793
        # Load the configuration
 
794
        self.read()
 
795
        
 
796
    def _get_default(self, option):
 
797
        """ Get the default option for a preference. """
 
798
        try:
 
799
            ret = self.defaults[option]
 
800
        except KeyError:
 
801
            return None
 
802
        else:
 
803
            return ret
 
804
 
 
805
    def refresh(self):
 
806
        """ Refresh the configuration. """
 
807
        # First write out the changes
 
808
        self.write()
 
809
        # Then load the configuration again
 
810
        self.read()
 
811
 
 
812
    def read(self):
 
813
        """ Just read the configuration. """
 
814
        if sys.platform == 'win32':
 
815
            # Windows - no dotted files
 
816
            self.config.read([os.path.expanduser('~/olive.conf')])
 
817
        else:
 
818
            self.config.read([os.path.expanduser('~/.olive.conf')])
 
819
    
 
820
    def write(self):
 
821
        """ Write the configuration to the appropriate files. """
 
822
        if sys.platform == 'win32':
 
823
            # Windows - no dotted files
 
824
            fp = open(os.path.expanduser('~/olive.conf'), 'w')
 
825
            self.config.write(fp)
 
826
            fp.close()
 
827
        else:
 
828
            fp = open(os.path.expanduser('~/.olive.conf'), 'w')
 
829
            self.config.write(fp)
 
830
            fp.close()
 
831
 
 
832
    def get_bookmarks(self):
 
833
        """ Return the list of bookmarks. """
 
834
        bookmarks = self.config.sections()
 
835
        if self.config.has_section('preferences'):
 
836
            bookmarks.remove('preferences')
 
837
        return bookmarks
 
838
 
 
839
    def add_bookmark(self, path):
 
840
        """ Add bookmark. """
 
841
        try:
 
842
            self.config.add_section(path)
 
843
        except ConfigParser.DuplicateSectionError:
 
844
            return False
 
845
        else:
 
846
            return True
 
847
 
 
848
    def get_bookmark_title(self, path):
 
849
        """ Get bookmark title. """
 
850
        try:
 
851
            ret = self.config.get(path, 'title')
 
852
        except ConfigParser.NoOptionError:
 
853
            ret = path
 
854
        
 
855
        return ret
 
856
    
 
857
    def set_bookmark_title(self, path, title):
 
858
        """ Set bookmark title. """
 
859
        self.config.set(path, 'title', title)
 
860
    
 
861
    def remove_bookmark(self, path):
 
862
        """ Remove bookmark. """
 
863
        return self.config.remove_section(path)
 
864
 
 
865
    def set_preference(self, option, value):
 
866
        """ Set the value of the given option. """
 
867
        if self.config.has_section('preferences'):
 
868
            self.config.set('preferences', option, value)
 
869
        else:
 
870
            self.config.add_section('preferences')
 
871
            self.config.set('preferences', option, value)
 
872
 
 
873
    def get_preference(self, option, kind='str'):
 
874
        """ Get the value of the given option.
 
875
        
 
876
        :param kind: str/bool/int/float. default: str
 
877
        """
 
878
        if self.config.has_option('preferences', option):
 
879
            if kind == 'bool':
 
880
                #return self.config.getboolean('preferences', option)
 
881
                return True
 
882
            elif kind == 'int':
 
883
                return self.config.getint('preferences', option)
 
884
            elif kind == 'float':
 
885
                return self.config.getfloat('preferences', option)
 
886
            else:
 
887
                return self.config.get('preferences', option)
 
888
        else:
 
889
            try:
 
890
                return self._get_default(option)
 
891
            except KeyError:
 
892
                return None
 
893