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

  • Committer: Jelmer Vernooij
  • Date: 2008-06-29 16:24:24 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629162424-48a6rrjmmpejfcyr
Stop emitting no longer used revisions-loaded message.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
try:
26
 
    import gtk
27
 
    import gtk.glade
28
 
except:
29
 
    sys.exit(1)
30
 
 
31
 
import bzrlib.errors as errors
32
 
from bzrlib.branch import Branch
33
 
from bzrlib.workingtree import WorkingTree
34
 
 
35
 
from dialog import OliveDialog
36
 
from menu import OliveMenu
37
 
from launch import launch
38
 
 
39
 
class OliveHandler:
40
 
    """ Signal handler class for Olive. """
41
 
    def __init__(self, gladefile, comm):
42
 
        self.gladefile = gladefile
43
 
        self.comm = comm
44
 
        
45
 
        self.dialog = OliveDialog(self.gladefile)
46
 
        
47
 
        self.menu = OliveMenu(self.gladefile, self.comm, self.dialog)
48
 
    
49
 
    def on_about_activate(self, widget):
50
 
        self.dialog.about()
51
 
        
52
 
    def on_menuitem_add_files_activate(self, widget):
53
 
        """ Add file(s)... menu handler. """
54
 
        from add import OliveAdd
55
 
        add = OliveAdd(self.gladefile, self.comm, self.dialog)
56
 
        add.display()
57
 
    
58
 
    def on_menuitem_branch_get_activate(self, widget):
59
 
        """ Branch/Get... menu handler. """
60
 
        from branch import OliveBranch
61
 
        branch = OliveBranch(self.gladefile, self.comm, self.dialog)
62
 
        branch.display()
63
 
    
64
 
    def on_menuitem_branch_checkout_activate(self, widget):
65
 
        """ Branch/Checkout... menu handler. """
66
 
        from checkout import OliveCheckout
67
 
        checkout = OliveCheckout(self.gladefile, self.comm, self.dialog)
68
 
        checkout.display()
69
 
    
70
 
    def on_menuitem_branch_commit_activate(self, widget):
71
 
        """ Branch/Commit... menu handler. """
72
 
        from commit import OliveCommit
73
 
        wt, path = WorkingTree.open_containing(self.comm.get_path())
74
 
        commit = OliveCommit(self.gladefile, wt, path, self.dialog)
75
 
        commit.display()
76
 
    
77
 
    def on_menuitem_branch_missing_revisions_activate(self, widget):
78
 
        """ Branch/Missing revisions menu handler. """
79
 
        
80
 
        self.comm.set_busy(self.comm.window_main)
81
 
        
82
 
        try:
83
 
            import bzrlib
84
 
            
85
 
            try:
86
 
                local_branch = Branch.open_containing(self.comm.get_path())[0]
87
 
            except NotBranchError:
88
 
                self.dialog.error_dialog(_('Directory is not a branch'),
89
 
                                         _('You can perform this action only in a branch.'))
90
 
                return
91
 
            
92
 
            other_branch = local_branch.get_parent()
93
 
            if other_branch is None:
94
 
                self.dialog.error_dialog(_('Parent location is unknown'),
95
 
                                         _('Cannot determine missing revisions if no parent location is known.'))
96
 
                return
97
 
            
98
 
            remote_branch = Branch.open(other_branch)
99
 
            
100
 
            if remote_branch.base == local_branch.base:
101
 
                remote_branch = local_branch
102
 
 
103
 
            ret = len(local_branch.missing_revisions(remote_branch))
104
 
 
105
 
            if ret > 0:
106
 
                self.dialog.info_dialog(_('There are missing revisions'),
107
 
                                        _('%d revision(s) missing.') % ret)
108
 
            else:
109
 
                self.dialog.info_dialog(_('Local branch up to date'),
110
 
                                        _('There are no missing revisions.'))
111
 
        finally:
112
 
            self.comm.set_busy(self.comm.window_main, False)
113
 
    
114
 
    def on_menuitem_branch_pull_activate(self, widget):
115
 
        """ Branch/Pull menu handler. """
116
 
        
117
 
        self.comm.set_busy(self.comm.window_main)
118
 
 
119
 
        try:
120
 
            try:
121
 
                from bzrlib.workingtree import WorkingTree
122
 
                tree_to = WorkingTree.open_containing(self.comm.get_path())[0]
123
 
                branch_to = tree_to.branch
124
 
            except errors.NoWorkingTree:
125
 
                tree_to = None
126
 
                branch_to = Branch.open_containing(self.comm.get_path())[0]
127
 
            except errors.NotBranchError:
128
 
                 self.dialog.error_dialog(_('Directory is not a branch'),
129
 
                                         _('You can perform this action only in a branch.'))
130
 
 
131
 
            location = branch_to.get_parent()
132
 
            if location is None:
133
 
                self.dialog.error_dialog(_('Parent location is unknown'),
134
 
                                         _('Pulling is not possible until there is a parent location.'))
135
 
                return
136
 
 
137
 
            try:
138
 
                branch_from = Branch.open(location)
139
 
            except errors.NotBranchError:
140
 
                self.dialog.error_dialog(_('Directory is not a branch'),
141
 
                                         _('You can perform this action only in a branch.'))
142
 
 
143
 
            if branch_to.get_parent() is None:
144
 
                branch_to.set_parent(branch_from.base)
145
 
 
146
 
            old_rh = branch_to.revision_history()
147
 
            if tree_to is not None:
148
 
                tree_to.pull(branch_from)
149
 
            else:
150
 
                branch_to.pull(branch_from)
151
 
            
152
 
            self.dialog.info_dialog(_('Pull successful'),
153
 
                                    _('%d revision(s) pulled.') % ret)
154
 
            
155
 
        finally:
156
 
            self.comm.set_busy(self.comm.window_main, False)
157
 
    
158
 
    def on_menuitem_branch_push_activate(self, widget):
159
 
        """ Branch/Push... menu handler. """
160
 
        from push import OlivePush
161
 
        push = OlivePush(self.gladefile, self.comm, self.dialog)
162
 
        push.display()
163
 
    
164
 
    def on_menuitem_branch_status_activate(self, widget):
165
 
        """ Branch/Status... menu handler. """
166
 
        from status import OliveStatus
167
 
        wt, wtpath = WorkingTree.open_containing(self.comm.get_path())
168
 
        status = OliveStatus(self.gladefile, wt, wtpath, self.dialog)
169
 
        status.display()
170
 
    
171
 
    def on_menuitem_branch_initialize_activate(self, widget):
172
 
        """ Initialize current directory. """
173
 
        try:
174
 
            location = self.comm.get_path()
175
 
            from bzrlib.builtins import get_format_type
176
 
 
177
 
            format = get_format_type('default')
178
 
 
179
 
            if not os.path.exists(location):
180
 
                os.mkdir(location)
181
 
     
182
 
            try:
183
 
                existing_bzrdir = bzrdir.BzrDir.open(location)
184
 
            except NotBranchError:
185
 
                bzrdir.BzrDir.create_branch_convenience(location, format=format)
186
 
            else:
187
 
                if existing_bzrdir.has_branch():
188
 
                    if existing_bzrdir.has_workingtree():
189
 
                        raise AlreadyBranchError(location)
190
 
                    else:
191
 
                        raise BranchExistsWithoutWorkingTree(location)
192
 
                else:
193
 
                    existing_bzrdir.create_branch()
194
 
                    existing_bzrdir.create_workingtree()
195
 
        except errors.AlreadyBranchError, errmsg:
196
 
            self.dialog.error_dialog(_('Directory is already a branch'),
197
 
                                     _('The current directory (%s) is already a branch.\nYou can start using it, or initialize another directory.') % errmsg)
198
 
        except errors.BranchExistsWithoutWorkingTree, errmsg:
199
 
            self.dialog.error_dialog(_('Branch without a working tree'),
200
 
                                     _('The current directory (%s)\nis a branch without a working tree.') % errmsg)
201
 
        else:
202
 
            self.dialog.info_dialog(_('Initialize successful'),
203
 
                                    _('Directory successfully initialized.'))
204
 
            self.comm.refresh_right()
205
 
        
206
 
    def on_menuitem_file_make_directory_activate(self, widget):
207
 
        """ File/Make directory... menu handler. """
208
 
        from mkdir import OliveMkdir
209
 
        mkdir = OliveMkdir(self.gladefile, self.comm, self.dialog)
210
 
        mkdir.display()
211
 
    
212
 
    def on_menuitem_file_move_activate(self, widget):
213
 
        """ File/Move... menu handler. """
214
 
        from move import OliveMove
215
 
        move = OliveMove(self.gladefile, self.comm, self.dialog)
216
 
        move.display()
217
 
    
218
 
    def on_menuitem_file_rename_activate(self, widget):
219
 
        """ File/Rename... menu handler. """
220
 
        from rename import OliveRename
221
 
        rename = OliveRename(self.gladefile, self.comm, self.dialog)
222
 
        rename.display()
223
 
 
224
 
    def on_menuitem_remove_file_activate(self, widget):
225
 
        """ Remove (unversion) selected file. """
226
 
        from remove import OliveRemove
227
 
        remove = OliveRemove(self.gladefile, self.comm, self.dialog)
228
 
        remove.display()
229
 
    
230
 
    def on_menuitem_stats_diff_activate(self, widget):
231
 
        """ Statistics/Differences... menu handler. """
232
 
        from diff import OliveDiff
233
 
        diff = OliveDiff(self.gladefile, self.comm, self.dialog)
234
 
        diff.display()
235
 
    
236
 
    def on_menuitem_stats_infos_activate(self, widget):
237
 
        """ Statistics/Informations... menu handler. """
238
 
        from info import OliveInfo
239
 
        info = OliveInfo(self.gladefile, self.comm, self.dialog)
240
 
        info.display()
241
 
    
242
 
    def on_menuitem_stats_log_activate(self, widget):
243
 
        """ Statistics/Log... menu handler. """
244
 
        from log import OliveLog
245
 
        log = OliveLog(self.gladefile, self.comm, self.dialog)
246
 
        log.display()
247
 
    
248
 
    def on_menuitem_view_refresh_activate(self, widget):
249
 
        """ View/Refresh menu handler. """
250
 
        # Refresh the left pane
251
 
        self.comm.refresh_left()
252
 
        # Refresh the right pane
253
 
        self.comm.refresh_right()
254
 
    
255
 
    def on_menuitem_view_show_hidden_files_activate(self, widget):
256
 
        """ View/Show hidden files menu handler. """
257
 
        if widget.get_active():
258
 
            # Show hidden files
259
 
            self.comm.pref.set_preference('dotted_files', True)
260
 
            self.comm.pref.refresh()
261
 
            self.comm.refresh_right()
262
 
        else:
263
 
            # Do not show hidden files
264
 
            self.comm.pref.set_preference('dotted_files', False)
265
 
            self.comm.pref.refresh()
266
 
            self.comm.refresh_right()
267
 
 
268
 
    def on_treeview_left_button_press_event(self, widget, event):
269
 
        """ Occurs when somebody right-clicks in the bookmark list. """
270
 
        if event.button == 3:
271
 
            # Don't show context with nothing selected
272
 
            if self.comm.get_selected_left() == None:
273
 
                return
274
 
 
275
 
            self.menu.left_context_menu().popup(None, None, None, 0,
276
 
                                                event.time)
277
 
        
278
 
    def on_treeview_left_row_activated(self, treeview, path, view_column):
279
 
        """ Occurs when somebody double-clicks or enters an item in the
280
 
        bookmark list. """
281
 
 
282
 
        newdir = self.comm.get_selected_left()
283
 
        if newdir == None:
284
 
            return
285
 
 
286
 
        self.comm.set_busy(treeview)
287
 
        self.comm.set_path(newdir)
288
 
        self.comm.refresh_right()
289
 
        self.comm.set_busy(treeview, False)
290
 
    
291
 
    def on_treeview_right_button_press_event(self, widget, event):
292
 
        """ Occurs when somebody right-clicks in the file list. """
293
 
        if event.button == 3:
294
 
            # get the menu items
295
 
            m_add = self.menu.ui.get_widget('/context_right/add')
296
 
            m_remove = self.menu.ui.get_widget('/context_right/remove')
297
 
            m_commit = self.menu.ui.get_widget('/context_right/commit')
298
 
            m_diff = self.menu.ui.get_widget('/context_right/diff')
299
 
            # check if we're in a branch
300
 
            try:
301
 
                from bzrlib.branch import Branch
302
 
                Branch.open_containing(self.comm.get_path())
303
 
                m_add.set_sensitive(False)
304
 
                m_remove.set_sensitive(False)
305
 
                m_commit.set_sensitive(False)
306
 
                m_diff.set_sensitive(False)
307
 
            except errors.NotBranchError:
308
 
                m_add.set_sensitive(True)
309
 
                m_remove.set_sensitive(True)
310
 
                m_commit.set_sensitive(True)
311
 
                m_diff.set_sensitive(True)
312
 
            self.menu.right_context_menu().popup(None, None, None, 0,
313
 
                                                 event.time)
314
 
        
315
 
    def on_treeview_right_row_activated(self, treeview, path, view_column):
316
 
        """ Occurs when somebody double-clicks or enters an item in the
317
 
        file list. """
318
 
        import os.path
319
 
        
320
 
        newdir = self.comm.get_selected_right()
321
 
        
322
 
        if newdir == '..':
323
 
            self.comm.set_path(os.path.split(self.comm.get_path())[0])
324
 
        else:
325
 
            fullpath = self.comm.get_path() + os.sep + newdir
326
 
            if os.path.isdir(fullpath):
327
 
                # selected item is an existant directory
328
 
                self.comm.set_path(fullpath)
329
 
            else:
330
 
                launch(fullpath) 
331
 
        
332
 
        self.comm.refresh_right()
333
 
    
334
 
    def on_window_main_delete_event(self, widget, event=None):
335
 
        """ Do some stuff before exiting. """
336
 
        width, height = self.comm.window_main.get_size()
337
 
        self.comm.pref.set_preference('window_width', width)
338
 
        self.comm.pref.set_preference('window_height', height)
339
 
        x, y = self.comm.window_main.get_position()
340
 
        self.comm.pref.set_preference('window_x', x)
341
 
        self.comm.pref.set_preference('window_y', y)
342
 
        self.comm.pref.set_preference('paned_position',
343
 
                                      self.comm.hpaned_main.get_position())
344
 
        
345
 
        self.comm.pref.write()
346
 
        self.comm.window_main.destroy()
347
 
 
348
 
    def not_implemented(self, widget):
349
 
        """ Display a Not implemented error message. """
350
 
        self.dialog.error_dialog(_('We feel sorry'),
351
 
                                 _('This feature is not yet implemented.'))
352