/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 20:30:59 UTC
  • mto: (0.12.2 olive)
  • mto: This revision was merged to the branch mainline in revision 83.
  • Revision ID: jelmer@samba.org-20060927203059-85792ae0a81db524
Bunch of small fixes, cleanups and simplifications.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/handler.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import os
17
18
import sys
18
19
 
19
20
try:
21
22
    pygtk.require("2.0")
22
23
except:
23
24
    pass
24
 
try:
25
 
    import gtk
26
 
    import gtk.glade
27
 
except:
28
 
    sys.exit(1)
29
 
 
30
 
from olive.backend.info import is_branch
31
 
import olive.backend.errors as errors
32
 
 
33
 
from dialog import OliveDialog
34
 
from menu import OliveMenu
 
25
 
 
26
import gtk
 
27
import gtk.glade
 
28
 
 
29
import bzrlib.errors as errors
 
30
from bzrlib.branch import Branch
 
31
from bzrlib.workingtree import WorkingTree
 
32
 
 
33
from dialog import about, error_dialog, info_dialog
35
34
from launch import launch
36
35
 
37
36
class OliveHandler:
38
37
    """ Signal handler class for Olive. """
39
 
    def __init__(self, gladefile, comm):
40
 
        self.gladefile = gladefile
41
 
        self.comm = comm
42
 
        
43
 
        self.dialog = OliveDialog(self.gladefile)
44
 
        
45
 
        self.menu = OliveMenu(self.gladefile, self.comm, self.dialog)
 
38
    def __init__(self, path):
 
39
        self.wt, self.path = WorkingTree.open_containing(path)
46
40
    
47
41
    def on_about_activate(self, widget):
48
 
        self.dialog.about()
 
42
        about()
49
43
        
50
44
    def on_menuitem_add_files_activate(self, widget):
51
45
        """ Add file(s)... menu handler. """
52
46
        from add import OliveAdd
53
 
        add = OliveAdd(self.gladefile, self.comm, self.dialog)
 
47
        add = OliveAdd(self.wt, self.path, self.comm.get_selected_right())
54
48
        add.display()
55
49
    
56
50
    def on_menuitem_branch_get_activate(self, widget):
57
51
        """ Branch/Get... menu handler. """
58
52
        from branch import OliveBranch
59
 
        branch = OliveBranch(self.gladefile, self.comm, self.dialog)
 
53
        branch = OliveBranch()
60
54
        branch.display()
61
55
    
62
56
    def on_menuitem_branch_checkout_activate(self, widget):
63
57
        """ Branch/Checkout... menu handler. """
64
58
        from checkout import OliveCheckout
65
 
        checkout = OliveCheckout(self.gladefile, self.comm, self.dialog)
 
59
        checkout = OliveCheckout()
66
60
        checkout.display()
67
61
    
68
62
    def on_menuitem_branch_commit_activate(self, widget):
69
63
        """ Branch/Commit... menu handler. """
70
64
        from commit import OliveCommit
71
 
        commit = OliveCommit(self.gladefile, self.comm, self.dialog)
 
65
        commit = OliveCommit(self.wt, self.path)
72
66
        commit.display()
73
67
    
74
68
    def on_menuitem_branch_missing_revisions_activate(self, widget):
75
69
        """ Branch/Missing revisions menu handler. """
76
 
        import olive.backend.update as update
77
70
        
78
71
        self.comm.set_busy(self.comm.window_main)
79
72
        
80
73
        try:
81
 
            ret = update.missing(self.comm.get_path())
82
 
        except errors.NotBranchError:
83
 
            self.dialog.error_dialog(_('Directory is not a branch'),
84
 
                                     _('You can perform this action only in a branch.'))
85
 
        except errors.ConnectionError:
86
 
            self.dialog.error_dialog(_('Connection error'),
87
 
                                     _('Cannot connect to remote location.\nPlease try again later.'))
88
 
        except errors.NoLocationKnown:
89
 
            self.dialog.error_dialog(_('Parent location is unknown'),
90
 
                                     _('Cannot determine missing revisions if no parent location is known.'))
91
 
        else:
 
74
            import bzrlib
 
75
            
 
76
            local_branch = self.wt.branch
 
77
            
 
78
            other_branch = local_branch.get_parent()
 
79
            if other_branch is None:
 
80
                error_dialog(_('Parent location is unknown'),
 
81
                                         _('Cannot determine missing revisions if no parent location is known.'))
 
82
                return
 
83
            
 
84
            remote_branch = Branch.open(other_branch)
 
85
            
 
86
            if remote_branch.base == local_branch.base:
 
87
                remote_branch = local_branch
 
88
 
 
89
            ret = len(local_branch.missing_revisions(remote_branch))
 
90
 
92
91
            if ret > 0:
93
 
                self.dialog.info_dialog(_('There are missing revisions'),
 
92
                info_dialog(_('There are missing revisions'),
94
93
                                        _('%d revision(s) missing.') % ret)
95
94
            else:
96
 
                self.dialog.info_dialog(_('Local branch up to date'),
 
95
                info_dialog(_('Local branch up to date'),
97
96
                                        _('There are no missing revisions.'))
98
 
        
99
 
        self.comm.set_busy(self.comm.window_main, False)
 
97
        finally:
 
98
            self.comm.set_busy(self.comm.window_main, False)
100
99
    
101
100
    def on_menuitem_branch_pull_activate(self, widget):
102
101
        """ Branch/Pull menu handler. """
103
 
        import olive.backend.update as update
104
102
        
105
103
        self.comm.set_busy(self.comm.window_main)
106
 
        
 
104
 
 
105
        branch_to = self.wt.branch
 
106
 
 
107
        location = branch_to.get_parent()
 
108
        if location is None:
 
109
            error_dialog(_('Parent location is unknown'),
 
110
                                     _('Pulling is not possible until there is a parent location.'))
 
111
            return
 
112
 
107
113
        try:
108
 
            ret = update.pull(self.comm.get_path())
 
114
            branch_from = Branch.open(location)
109
115
        except errors.NotBranchError:
110
 
            self.dialog.error_dialog(_('Directory is not a branch'),
 
116
            error_dialog(_('Directory is not a branch'),
111
117
                                     _('You can perform this action only in a branch.'))
112
 
        except errors.NoLocationKnown:
113
 
            self.dialog.error_dialog(_('Parent location is unknown'),
114
 
                                     _('Pulling is not possible until there is no parent location.'))
 
118
 
 
119
        if branch_to.get_parent() is None:
 
120
            branch_to.set_parent(branch_from.base)
 
121
 
 
122
        old_rh = branch_to.revision_history()
 
123
        if tree_to is not None:
 
124
            tree_to.pull(branch_from)
115
125
        else:
116
 
            self.dialog.info_dialog(_('Pull successful'),
117
 
                                    _('%d revision(s) pulled.') % ret)
 
126
            branch_to.pull(branch_from)
118
127
        
119
 
        self.comm.set_busy(self.comm.window_main, False)
 
128
        info_dialog(_('Pull successful'), _('%d revision(s) pulled.') % ret)
120
129
    
121
130
    def on_menuitem_branch_push_activate(self, widget):
122
131
        """ Branch/Push... menu handler. """
123
132
        from push import OlivePush
124
 
        push = OlivePush(self.gladefile, self.comm, self.dialog)
 
133
        push = OlivePush(self.comm)
125
134
        push.display()
126
135
    
127
136
    def on_menuitem_branch_status_activate(self, widget):
128
137
        """ Branch/Status... menu handler. """
129
138
        from status import OliveStatus
130
 
        status = OliveStatus(self.gladefile, self.comm, self.dialog)
 
139
        status = OliveStatus(self.wt, self.path)
131
140
        status.display()
132
141
    
133
142
    def on_menuitem_branch_initialize_activate(self, widget):
134
143
        """ Initialize current directory. """
135
 
        import olive.backend.init as init
136
 
        
137
144
        try:
138
 
            init.init(self.comm.get_path())
 
145
            location = self.comm.get_path()
 
146
            from bzrlib.builtins import get_format_type
 
147
 
 
148
            format = get_format_type('default')
 
149
 
 
150
            if not os.path.exists(location):
 
151
                os.mkdir(location)
 
152
     
 
153
            try:
 
154
                existing_bzrdir = bzrdir.BzrDir.open(location)
 
155
            except NotBranchError:
 
156
                bzrdir.BzrDir.create_branch_convenience(location, format=format)
 
157
            else:
 
158
                if existing_bzrdir.has_branch():
 
159
                    if existing_bzrdir.has_workingtree():
 
160
                        raise AlreadyBranchError(location)
 
161
                    else:
 
162
                        raise BranchExistsWithoutWorkingTree(location)
 
163
                else:
 
164
                    existing_bzrdir.create_branch()
 
165
                    existing_bzrdir.create_workingtree()
139
166
        except errors.AlreadyBranchError, errmsg:
140
 
            self.dialog.error_dialog(_('Directory is already a branch'),
 
167
            error_dialog(_('Directory is already a branch'),
141
168
                                     _('The current directory (%s) is already a branch.\nYou can start using it, or initialize another directory.') % errmsg)
142
169
        except errors.BranchExistsWithoutWorkingTree, errmsg:
143
 
            self.dialog.error_dialog(_('Branch without a working tree'),
 
170
            error_dialog(_('Branch without a working tree'),
144
171
                                     _('The current directory (%s)\nis a branch without a working tree.') % errmsg)
145
 
        except:
146
 
            raise
147
172
        else:
148
 
            self.dialog.info_dialog(_('Ininialize successful'),
 
173
            info_dialog(_('Initialize successful'),
149
174
                                    _('Directory successfully initialized.'))
150
175
            self.comm.refresh_right()
151
176
        
152
177
    def on_menuitem_file_make_directory_activate(self, widget):
153
178
        """ File/Make directory... menu handler. """
154
179
        from mkdir import OliveMkdir
155
 
        mkdir = OliveMkdir(self.gladefile, self.comm, self.dialog)
 
180
        mkdir = OliveMkdir(self.comm)
156
181
        mkdir.display()
157
182
    
158
183
    def on_menuitem_file_move_activate(self, widget):
159
184
        """ File/Move... menu handler. """
160
185
        from move import OliveMove
161
 
        move = OliveMove(self.gladefile, self.comm, self.dialog)
 
186
        move = OliveMove(self.comm)
162
187
        move.display()
163
188
    
164
189
    def on_menuitem_file_rename_activate(self, widget):
165
190
        """ File/Rename... menu handler. """
166
191
        from rename import OliveRename
167
 
        rename = OliveRename(self.gladefile, self.comm, self.dialog)
 
192
        rename = OliveRename(self.comm)
168
193
        rename.display()
169
194
 
170
195
    def on_menuitem_remove_file_activate(self, widget):
171
196
        """ Remove (unversion) selected file. """
172
197
        from remove import OliveRemove
173
 
        remove = OliveRemove(self.gladefile, self.comm, self.dialog)
 
198
        remove = OliveRemove(self.comm)
174
199
        remove.display()
175
200
    
176
201
    def on_menuitem_stats_diff_activate(self, widget):
177
202
        """ Statistics/Differences... menu handler. """
178
 
        from diff import OliveDiff
179
 
        diff = OliveDiff(self.gladefile, self.comm, self.dialog)
180
 
        diff.display()
 
203
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
 
204
        window = DiffWindow()
 
205
        parent_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
 
206
        window.set_diff(self.wt.branch.nick, self.wt, parent_tree)
 
207
        window.show()
181
208
    
182
209
    def on_menuitem_stats_infos_activate(self, widget):
183
210
        """ Statistics/Informations... menu handler. """
184
211
        from info import OliveInfo
185
 
        info = OliveInfo(self.gladefile, self.comm, self.dialog)
 
212
        info = OliveInfo(self.comm)
186
213
        info.display()
187
214
    
188
215
    def on_menuitem_stats_log_activate(self, widget):
189
216
        """ Statistics/Log... menu handler. """
190
217
        from log import OliveLog
191
 
        log = OliveLog(self.gladefile, self.comm, self.dialog)
 
218
        log = OliveLog(self.comm)
192
219
        log.display()
193
220
    
194
221
    def on_menuitem_view_refresh_activate(self, widget):
243
270
            m_commit = self.menu.ui.get_widget('/context_right/commit')
244
271
            m_diff = self.menu.ui.get_widget('/context_right/diff')
245
272
            # check if we're in a branch
246
 
            if not is_branch(self.comm.get_path()):
 
273
            try:
 
274
                from bzrlib.branch import Branch
 
275
                Branch.open_containing(self.comm.get_path())
247
276
                m_add.set_sensitive(False)
248
277
                m_remove.set_sensitive(False)
249
278
                m_commit.set_sensitive(False)
250
279
                m_diff.set_sensitive(False)
251
 
            else:
 
280
            except errors.NotBranchError:
252
281
                m_add.set_sensitive(True)
253
282
                m_remove.set_sensitive(True)
254
283
                m_commit.set_sensitive(True)
289
318
        self.comm.pref.write()
290
319
        self.comm.window_main.destroy()
291
320
 
292
 
    def not_implemented(self, widget):
293
 
        """ Display a Not implemented error message. """
294
 
        self.dialog.error_dialog(_('We feel sorry'),
295
 
                                 _('This feature is not yet implemented.'))
296
321