/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: 2006-09-27 17:25:14 UTC
  • mto: (0.12.2 olive)
  • mto: This revision was merged to the branch mainline in revision 83.
  • Revision ID: jelmer@samba.org-20060927172514-9d1dfd3902d9a255
Remove communicator use from Commit.

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