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

  • Committer: Jelmer Vernooij
  • Date: 2007-02-03 14:19:44 UTC
  • Revision ID: jelmer@samba.org-20070203141944-oa6iqhetsy0slqo0
Fix references to dialog.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
14
14
 
15
15
"""GTK+ frontends to Bazaar commands """
16
16
 
 
17
import bzrlib
 
18
 
 
19
__version__ = '0.15.0'
 
20
version_info = tuple(int(n) for n in __version__.split('.'))
 
21
 
 
22
 
 
23
def check_bzrlib_version(desired):
 
24
    """Check that bzrlib is compatible.
 
25
 
 
26
    If version is < bzr-gtk version, assume incompatible.
 
27
    If version == bzr-gtk version, assume completely compatible
 
28
    If version == bzr-gtk version + 1, assume compatible, with deprecations
 
29
    Otherwise, assume incompatible.
 
30
    """
 
31
    desired_plus = (desired[0], desired[1]+1)
 
32
    bzrlib_version = bzrlib.version_info[:2]
 
33
    if bzrlib_version == desired:
 
34
        return
 
35
    try:
 
36
        from bzrlib.trace import warning
 
37
    except ImportError:
 
38
        # get the message out any way we can
 
39
        from warnings import warn as warning
 
40
    if bzrlib_version < desired:
 
41
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
 
42
                ' %s.' % (bzrlib.__version__, __version__))
 
43
        # Not using BzrNewError, because it may not exist.
 
44
        raise Exception, ('Version mismatch', version_info)
 
45
    else:
 
46
        warning('bzr-gtk is not up to date with installed bzr version %s.'
 
47
                ' \nThere should be a newer version available, e.g. %i.%i.' 
 
48
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
 
49
        if bzrlib_version != desired_plus:
 
50
            raise Exception, 'Version mismatch'
 
51
 
 
52
 
 
53
check_bzrlib_version(version_info[:2])
 
54
 
 
55
from bzrlib.trace import warning
 
56
if __name__ != 'bzrlib.plugins.gtk':
 
57
    warning("Not running as bzrlib.plugins.gtk, things may break.")
 
58
 
 
59
from bzrlib import errors
17
60
from bzrlib.commands import Command, register_command, display_command
18
61
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
19
62
from bzrlib.commands import Command, register_command
22
65
from bzrlib.workingtree import WorkingTree
23
66
from bzrlib.bzrdir import BzrDir
24
67
 
25
 
__version__ = '0.13.0'
 
68
import os.path
 
69
 
 
70
def import_pygtk():
 
71
    try:
 
72
        import pygtk
 
73
    except ImportError:
 
74
        raise errors.BzrCommandError("PyGTK not installed.")
 
75
    pygtk.require('2.0')
 
76
    return pygtk
 
77
 
 
78
 
 
79
def set_ui_factory():
 
80
    pygtk = import_pygtk()
 
81
    from ui import GtkUIFactory
 
82
    import bzrlib.ui
 
83
    bzrlib.ui.ui_factory = GtkUIFactory()
 
84
 
26
85
 
27
86
class cmd_gbranch(Command):
28
87
    """GTK+ branching.
30
89
    """
31
90
 
32
91
    def run(self):
33
 
        import pygtk
34
 
        pygtk.require("2.0")
 
92
        pygtk = import_pygtk()
35
93
        try:
36
94
            import gtk
37
95
        except RuntimeError, e:
38
96
            if str(e) == "could not open display":
39
97
                raise NoDisplayError
40
98
 
41
 
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
 
99
        from bzrlib.plugins.gtk.branch import BranchDialog
42
100
 
43
 
        window = BranchDialog('.')
44
 
        window.display()
 
101
        set_ui_factory()
 
102
        dialog = BranchDialog(os.path.abspath('.'))
 
103
        dialog.run()
45
104
 
46
105
register_command(cmd_gbranch)
47
106
 
 
107
class cmd_gcheckout(Command):
 
108
    """ GTK+ checkout.
 
109
    
 
110
    """
 
111
    
 
112
    def run(self):
 
113
        pygtk = import_pygtk()
 
114
        try:
 
115
            import gtk
 
116
        except RuntimeError, e:
 
117
            if str(e) == "could not open display":
 
118
                raise NoDisplayError
 
119
 
 
120
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
 
121
 
 
122
        set_ui_factory()
 
123
        dialog = CheckoutDialog(os.path.abspath('.'))
 
124
        dialog.run()
 
125
 
 
126
register_command(cmd_gcheckout)
 
127
 
 
128
class cmd_gpush(Command):
 
129
    """ GTK+ push.
 
130
    
 
131
    """
 
132
    takes_args = [ "location?" ]
 
133
    
 
134
    def run(self, location="."):
 
135
        (branch, path) = Branch.open_containing(location)
 
136
        
 
137
        pygtk = import_pygtk()
 
138
        try:
 
139
            import gtk
 
140
        except RuntimeError, e:
 
141
            if str(e) == "could not open display":
 
142
                raise NoDisplayError
 
143
 
 
144
        from push import PushDialog
 
145
 
 
146
        set_ui_factory()
 
147
        dialog = PushDialog(branch)
 
148
        dialog.run()
 
149
 
 
150
register_command(cmd_gpush)
 
151
 
48
152
class cmd_gdiff(Command):
49
153
    """Show differences in working tree in a GTK+ Window.
50
154
    
55
159
 
56
160
    @display_command
57
161
    def run(self, revision=None, filename=None):
 
162
        set_ui_factory()
58
163
        wt = WorkingTree.open_containing(".")[0]
59
164
        branch = wt.branch
60
165
        if revision is not None:
71
176
            tree1 = wt
72
177
            tree2 = tree1.basis_tree()
73
178
 
74
 
        from viz.diffwin import DiffWindow
 
179
        from diff import DiffWindow
75
180
        import gtk
76
181
        window = DiffWindow()
77
 
        window.connect("destroy", lambda w: gtk.main_quit())
 
182
        window.connect("destroy", gtk.main_quit)
78
183
        window.set_diff("Working Tree", tree1, tree2)
79
184
        if filename is not None:
80
185
            tree_filename = wt.relpath(filename)
109
214
    aliases = [ "visualize", "vis", "viz" ]
110
215
 
111
216
    def run(self, location=".", revision=None, limit=None):
 
217
        set_ui_factory()
112
218
        (branch, path) = Branch.open_containing(location)
113
219
        branch.lock_read()
114
220
        branch.repository.lock_read()
120
226
            else:
121
227
                (revno, revid) = revision[0].in_history(branch)
122
228
 
123
 
            from viz.bzrkapp import BzrkApp
 
229
            from viz.branchwin import BranchWindow
 
230
            import gtk
124
231
                
125
 
            app = BzrkApp()
126
 
            app.show(branch, revid, limit)
 
232
            pp = BranchWindow()
 
233
            pp.set_branch(branch, revid, limit)
 
234
            pp.connect("destroy", lambda w: gtk.main_quit())
 
235
            pp.show()
 
236
            gtk.main()
127
237
        finally:
128
238
            branch.repository.unlock()
129
239
            branch.unlock()
130
 
        app.main()
131
240
 
132
241
 
133
242
register_command(cmd_visualise)
149
258
    aliases = ["gblame", "gpraise"]
150
259
    
151
260
    def run(self, filename, all=False, plain=False, line='1', revision=None):
152
 
        import pygtk
153
 
        pygtk.require("2.0")
 
261
        pygtk = import_pygtk()
154
262
 
155
263
        try:
156
264
            import gtk
157
265
        except RuntimeError, e:
158
266
            if str(e) == "could not open display":
159
267
                raise NoDisplayError
 
268
        set_ui_factory()
160
269
 
161
270
        try:
162
271
            line = int(line)
167
276
        from annotate.gannotate import GAnnotateWindow
168
277
        from annotate.config import GAnnotateConfig
169
278
 
170
 
        (wt, path) = WorkingTree.open_containing(filename)
171
 
        branch = wt.branch
 
279
        try:
 
280
            (tree, path) = WorkingTree.open_containing(filename)
 
281
            branch = tree.branch
 
282
        except errors.NoWorkingTree:
 
283
            (branch, path) = Branch.open_containing(filename)
 
284
            tree = branch.basis_tree()
172
285
 
173
 
        file_id = wt.path2id(path)
 
286
        file_id = tree.path2id(path)
174
287
 
175
288
        if file_id is None:
176
289
            raise NotVersionedError(filename)
178
291
            if len(revision) != 1:
179
292
                raise BzrCommandError("Only 1 revion may be specified.")
180
293
            revision_id = revision[0].in_history(branch).rev_id
 
294
            tree = branch.repository.revision_tree(revision_id)
181
295
        else:
182
 
            revision_id = None
 
296
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
183
297
 
184
298
        window = GAnnotateWindow(all, plain)
185
299
        window.connect("destroy", lambda w: gtk.main_quit())
188
302
        window.show()
189
303
        branch.lock_read()
190
304
        try:
191
 
            window.annotate(branch, file_id, revision_id)
 
305
            window.annotate(tree, branch, file_id)
192
306
        finally:
193
307
            branch.unlock()
194
308
        window.jump_to_line(line)
202
316
 
203
317
    Graphical user interface for committing revisions"""
204
318
    
 
319
    aliases = [ "gci" ]
205
320
    takes_args = []
206
321
    takes_options = []
207
322
 
208
323
    def run(self, filename=None):
209
324
        import os
210
 
        import pygtk
211
 
        pygtk.require("2.0")
 
325
        pygtk = import_pygtk()
212
326
 
213
327
        try:
214
328
            import gtk
216
330
            if str(e) == "could not open display":
217
331
                raise NoDisplayError
218
332
 
219
 
        from olive.commit import CommitDialog
 
333
        set_ui_factory()
 
334
        from commit import CommitDialog
220
335
        from bzrlib.commit import Commit
221
336
        from bzrlib.errors import (BzrCommandError,
222
337
                                   NotBranchError,
239
354
            except NotBranchError, e:
240
355
                path = e.path
241
356
 
242
 
        dialog = CommitDialog(wt, path, not branch)
243
 
        if dialog.display():
244
 
            dialog.window.connect("destroy", lambda w: gtk.main_quit())
245
 
            gtk.main()
 
357
 
 
358
        commit = CommitDialog(wt, path, not branch)
 
359
        commit.run()
246
360
 
247
361
register_command(cmd_gcommit)
248
362
 
 
363
import gettext
 
364
gettext.install('olive-gtk')
 
365
 
249
366
class NoDisplayError(BzrCommandError):
250
367
    """gtk could not find a proper display"""
251
368
 
252
369
    def __str__(self):
253
 
        return "No DISPLAY. gannotate is disabled."
 
370
        return "No DISPLAY. Unable to run GTK+ application."
 
371
 
 
372
def test_suite():
 
373
    from unittest import TestSuite
 
374
    import tests
 
375
    result = TestSuite()
 
376
    result.addTest(tests.test_suite())
 
377
    return result