/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-03-13 16:48:48 UTC
  • Revision ID: jelmer@samba.org-20070313164848-x8j21t8u7ege6ml0
Initial work on a preferences dialog in GTK+, including a list of plugins with metadata browser.

Screenshot at http://samba.org/~jelmer/bzr/bzr-pluginlist.png

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.16.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.lazy_import import lazy_import
 
60
lazy_import(globals(), """
 
61
from bzrlib import (
 
62
    branch,
 
63
    errors,
 
64
    workingtree,
 
65
    )
 
66
""")
 
67
 
17
68
from bzrlib.commands import Command, register_command, display_command
18
69
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
19
70
from bzrlib.commands import Command, register_command
20
71
from bzrlib.option import Option
21
 
from bzrlib.branch import Branch
22
 
from bzrlib.workingtree import WorkingTree
23
72
from bzrlib.bzrdir import BzrDir
24
73
 
25
 
__version__ = '0.13.0'
 
74
import os.path
 
75
 
 
76
def import_pygtk():
 
77
    try:
 
78
        import pygtk
 
79
    except ImportError:
 
80
        raise errors.BzrCommandError("PyGTK not installed.")
 
81
    pygtk.require('2.0')
 
82
    return pygtk
 
83
 
 
84
 
 
85
def set_ui_factory():
 
86
    pygtk = import_pygtk()
 
87
    from ui import GtkUIFactory
 
88
    import bzrlib.ui
 
89
    bzrlib.ui.ui_factory = GtkUIFactory()
 
90
 
26
91
 
27
92
class cmd_gbranch(Command):
28
93
    """GTK+ branching.
30
95
    """
31
96
 
32
97
    def run(self):
33
 
        import pygtk
34
 
        pygtk.require("2.0")
 
98
        pygtk = import_pygtk()
35
99
        try:
36
100
            import gtk
37
101
        except RuntimeError, e:
38
102
            if str(e) == "could not open display":
39
103
                raise NoDisplayError
40
104
 
41
 
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
 
105
        from bzrlib.plugins.gtk.branch import BranchDialog
42
106
 
43
 
        window = BranchDialog('.')
44
 
        window.display()
 
107
        set_ui_factory()
 
108
        dialog = BranchDialog(os.path.abspath('.'))
 
109
        dialog.run()
45
110
 
46
111
register_command(cmd_gbranch)
47
112
 
 
113
class cmd_gcheckout(Command):
 
114
    """ GTK+ checkout.
 
115
    
 
116
    """
 
117
    
 
118
    def run(self):
 
119
        pygtk = import_pygtk()
 
120
        try:
 
121
            import gtk
 
122
        except RuntimeError, e:
 
123
            if str(e) == "could not open display":
 
124
                raise NoDisplayError
 
125
 
 
126
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
 
127
 
 
128
        set_ui_factory()
 
129
        dialog = CheckoutDialog(os.path.abspath('.'))
 
130
        dialog.run()
 
131
 
 
132
register_command(cmd_gcheckout)
 
133
 
 
134
class cmd_gpush(Command):
 
135
    """ GTK+ push.
 
136
    
 
137
    """
 
138
    takes_args = [ "location?" ]
 
139
 
 
140
    def run(self, location="."):
 
141
        (br, path) = branch.Branch.open_containing(location)
 
142
 
 
143
        pygtk = import_pygtk()
 
144
        try:
 
145
            import gtk
 
146
        except RuntimeError, e:
 
147
            if str(e) == "could not open display":
 
148
                raise NoDisplayError
 
149
 
 
150
        from push import PushDialog
 
151
 
 
152
        set_ui_factory()
 
153
        dialog = PushDialog(br)
 
154
        dialog.run()
 
155
 
 
156
register_command(cmd_gpush)
 
157
 
48
158
class cmd_gdiff(Command):
49
159
    """Show differences in working tree in a GTK+ Window.
50
160
    
55
165
 
56
166
    @display_command
57
167
    def run(self, revision=None, filename=None):
58
 
        wt = WorkingTree.open_containing(".")[0]
59
 
        branch = wt.branch
60
 
        if revision is not None:
61
 
            if len(revision) == 1:
 
168
        set_ui_factory()
 
169
        wt = workingtree.WorkingTree.open_containing(".")[0]
 
170
        wt.lock_read()
 
171
        try:
 
172
            branch = wt.branch
 
173
            if revision is not None:
 
174
                if len(revision) == 1:
 
175
                    tree1 = wt
 
176
                    revision_id = revision[0].in_history(branch).rev_id
 
177
                    tree2 = branch.repository.revision_tree(revision_id)
 
178
                elif len(revision) == 2:
 
179
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
180
                    tree2 = branch.repository.revision_tree(revision_id_0)
 
181
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
182
                    tree1 = branch.repository.revision_tree(revision_id_1)
 
183
            else:
62
184
                tree1 = wt
63
 
                revision_id = revision[0].in_history(branch).rev_id
64
 
                tree2 = branch.repository.revision_tree(revision_id)
65
 
            elif len(revision) == 2:
66
 
                revision_id_0 = revision[0].in_history(branch).rev_id
67
 
                tree2 = branch.repository.revision_tree(revision_id_0)
68
 
                revision_id_1 = revision[1].in_history(branch).rev_id
69
 
                tree1 = branch.repository.revision_tree(revision_id_1)
70
 
        else:
71
 
            tree1 = wt
72
 
            tree2 = tree1.basis_tree()
73
 
 
74
 
        from viz.diffwin import DiffWindow
75
 
        import gtk
76
 
        window = DiffWindow()
77
 
        window.connect("destroy", lambda w: gtk.main_quit())
78
 
        window.set_diff("Working Tree", tree1, tree2)
79
 
        if filename is not None:
80
 
            tree_filename = wt.relpath(filename)
81
 
            try:
82
 
                window.set_file(tree_filename)
83
 
            except NoSuchFile:
84
 
                if (tree1.inventory.path2id(tree_filename) is None and 
85
 
                    tree2.inventory.path2id(tree_filename) is None):
86
 
                    raise NotVersionedError(filename)
87
 
                raise BzrCommandError('No changes found for file "%s"' % 
88
 
                                      filename)
89
 
        window.show()
90
 
 
91
 
        gtk.main()
 
185
                tree2 = tree1.basis_tree()
 
186
 
 
187
            from diff import DiffWindow
 
188
            import gtk
 
189
            window = DiffWindow()
 
190
            window.connect("destroy", gtk.main_quit)
 
191
            window.set_diff("Working Tree", tree1, tree2)
 
192
            if filename is not None:
 
193
                tree_filename = wt.relpath(filename)
 
194
                try:
 
195
                    window.set_file(tree_filename)
 
196
                except NoSuchFile:
 
197
                    if (tree1.inventory.path2id(tree_filename) is None and 
 
198
                        tree2.inventory.path2id(tree_filename) is None):
 
199
                        raise NotVersionedError(filename)
 
200
                    raise BzrCommandError('No changes found for file "%s"' % 
 
201
                                          filename)
 
202
            window.show()
 
203
 
 
204
            gtk.main()
 
205
        finally:
 
206
            wt.unlock()
92
207
 
93
208
register_command(cmd_gdiff)
94
209
 
109
224
    aliases = [ "visualize", "vis", "viz" ]
110
225
 
111
226
    def run(self, location=".", revision=None, limit=None):
112
 
        (branch, path) = Branch.open_containing(location)
113
 
        branch.lock_read()
114
 
        branch.repository.lock_read()
 
227
        set_ui_factory()
 
228
        (br, path) = branch.Branch.open_containing(location)
 
229
        br.lock_read()
 
230
        br.repository.lock_read()
115
231
        try:
116
232
            if revision is None:
117
 
                revid = branch.last_revision()
 
233
                revid = br.last_revision()
118
234
                if revid is None:
119
235
                    return
120
236
            else:
121
 
                (revno, revid) = revision[0].in_history(branch)
 
237
                (revno, revid) = revision[0].in_history(br)
122
238
 
123
 
            from viz.bzrkapp import BzrkApp
 
239
            from viz.branchwin import BranchWindow
 
240
            import gtk
124
241
                
125
 
            app = BzrkApp()
126
 
            app.show(branch, revid, limit)
 
242
            pp = BranchWindow()
 
243
            pp.set_branch(br, revid, limit)
 
244
            pp.connect("destroy", lambda w: gtk.main_quit())
 
245
            pp.show()
 
246
            gtk.main()
127
247
        finally:
128
 
            branch.repository.unlock()
129
 
            branch.unlock()
130
 
        app.main()
 
248
            br.repository.unlock()
 
249
            br.unlock()
131
250
 
132
251
 
133
252
register_command(cmd_visualise)
149
268
    aliases = ["gblame", "gpraise"]
150
269
    
151
270
    def run(self, filename, all=False, plain=False, line='1', revision=None):
152
 
        import pygtk
153
 
        pygtk.require("2.0")
 
271
        pygtk = import_pygtk()
154
272
 
155
273
        try:
156
274
            import gtk
157
275
        except RuntimeError, e:
158
276
            if str(e) == "could not open display":
159
277
                raise NoDisplayError
 
278
        set_ui_factory()
160
279
 
161
280
        try:
162
281
            line = int(line)
167
286
        from annotate.gannotate import GAnnotateWindow
168
287
        from annotate.config import GAnnotateConfig
169
288
 
170
 
        (wt, path) = WorkingTree.open_containing(filename)
171
 
        branch = wt.branch
 
289
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
 
290
        if wt is not None:
 
291
            tree = wt
 
292
        else:
 
293
            tree = br.basis_tree()
172
294
 
173
 
        file_id = wt.path2id(path)
 
295
        file_id = tree.path2id(path)
174
296
 
175
297
        if file_id is None:
176
298
            raise NotVersionedError(filename)
177
299
        if revision is not None:
178
300
            if len(revision) != 1:
179
301
                raise BzrCommandError("Only 1 revion may be specified.")
180
 
            revision_id = revision[0].in_history(branch).rev_id
 
302
            revision_id = revision[0].in_history(br).rev_id
 
303
            tree = br.repository.revision_tree(revision_id)
181
304
        else:
182
 
            revision_id = None
 
305
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
183
306
 
184
307
        window = GAnnotateWindow(all, plain)
185
308
        window.connect("destroy", lambda w: gtk.main_quit())
186
309
        window.set_title(path + " - gannotate")
187
310
        config = GAnnotateConfig(window)
188
311
        window.show()
189
 
        branch.lock_read()
 
312
        br.lock_read()
 
313
        if wt is not None:
 
314
            wt.lock_read()
190
315
        try:
191
 
            window.annotate(branch, file_id, revision_id)
 
316
            window.annotate(tree, br, file_id)
 
317
            window.jump_to_line(line)
 
318
            gtk.main()
192
319
        finally:
193
 
            branch.unlock()
194
 
        window.jump_to_line(line)
195
 
        
196
 
        gtk.main()
 
320
            br.unlock()
 
321
            if wt is not None:
 
322
                wt.unlock()
197
323
 
198
324
register_command(cmd_gannotate)
199
325
 
202
328
 
203
329
    Graphical user interface for committing revisions"""
204
330
    
 
331
    aliases = [ "gci" ]
205
332
    takes_args = []
206
333
    takes_options = []
207
334
 
208
335
    def run(self, filename=None):
209
336
        import os
210
 
        import pygtk
211
 
        pygtk.require("2.0")
 
337
        pygtk = import_pygtk()
212
338
 
213
339
        try:
214
340
            import gtk
216
342
            if str(e) == "could not open display":
217
343
                raise NoDisplayError
218
344
 
219
 
        from olive.commit import CommitDialog
 
345
        set_ui_factory()
 
346
        from commit import CommitDialog
220
347
        from bzrlib.commit import Commit
221
348
        from bzrlib.errors import (BzrCommandError,
222
349
                                   NotBranchError,
226
353
                                   StrictCommitFailed)
227
354
 
228
355
        wt = None
229
 
        branch = None
 
356
        br = None
230
357
        try:
231
 
            (wt, path) = WorkingTree.open_containing(filename)
232
 
            branch = wt.branch
 
358
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
 
359
            br = wt.branch
233
360
        except NotBranchError, e:
234
361
            path = e.path
235
362
        except NoWorkingTree, e:
236
363
            path = e.base
237
364
            try:
238
 
                (branch, path) = Branch.open_containing(path)
 
365
                (br, path) = branch.Branch.open_containing(path)
239
366
            except NotBranchError, e:
240
367
                path = e.path
241
368
 
242
 
        dialog = CommitDialog(wt, path, not branch)
243
 
        if dialog.display():
244
 
            dialog.window.connect("destroy", lambda w: gtk.main_quit())
245
 
            gtk.main()
 
369
 
 
370
        commit = CommitDialog(wt, path, not br)
 
371
        commit.run()
246
372
 
247
373
register_command(cmd_gcommit)
248
374
 
 
375
class cmd_gstatus(Command):
 
376
    """GTK+ status dialog
 
377
 
 
378
    Graphical user interface for showing status 
 
379
    information."""
 
380
    
 
381
    aliases = [ "gst" ]
 
382
    takes_args = ['PATH?']
 
383
    takes_options = []
 
384
 
 
385
    def run(self, path='.'):
 
386
        import os
 
387
        pygtk = import_pygtk()
 
388
 
 
389
        try:
 
390
            import gtk
 
391
        except RuntimeError, e:
 
392
            if str(e) == "could not open display":
 
393
                raise NoDisplayError
 
394
 
 
395
        set_ui_factory()
 
396
        from status import StatusDialog
 
397
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
 
398
        status = StatusDialog(wt, wt_path)
 
399
        status.connect("destroy", gtk.main_quit)
 
400
        status.run()
 
401
 
 
402
register_command(cmd_gstatus)
 
403
 
 
404
class cmd_gconflicts(Command):
 
405
    """ GTK+ push.
 
406
    
 
407
    """
 
408
    def run(self):
 
409
        (wt, path) = workingtree.WorkingTree.open_containing('.')
 
410
        
 
411
        pygtk = import_pygtk()
 
412
        try:
 
413
            import gtk
 
414
        except RuntimeError, e:
 
415
            if str(e) == "could not open display":
 
416
                raise NoDisplayError
 
417
 
 
418
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
 
419
 
 
420
        set_ui_factory()
 
421
        dialog = ConflictsDialog(wt)
 
422
        dialog.run()
 
423
 
 
424
register_command(cmd_gconflicts)
 
425
 
 
426
class cmd_gpreferences(Command):
 
427
    """ GTK+ preferences dialog.
 
428
 
 
429
    """
 
430
    def run(self):
 
431
        pygtk = import_pygtk()
 
432
        try:
 
433
            import gtk
 
434
        except RuntimeError, e:
 
435
            if str(e) == "could not open display":
 
436
                raise NoDisplayError
 
437
 
 
438
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
 
439
 
 
440
        set_ui_factory()
 
441
        dialog = PreferencesWindow()
 
442
        dialog.run()
 
443
 
 
444
register_command(cmd_gpreferences)
 
445
 
 
446
import gettext
 
447
gettext.install('olive-gtk')
 
448
 
249
449
class NoDisplayError(BzrCommandError):
250
450
    """gtk could not find a proper display"""
251
451
 
252
452
    def __str__(self):
253
 
        return "No DISPLAY. gannotate is disabled."
 
453
        return "No DISPLAY. Unable to run GTK+ application."
 
454
 
 
455
def test_suite():
 
456
    from unittest import TestSuite
 
457
    import tests
 
458
    import sys
 
459
    default_encoding = sys.getdefaultencoding()
 
460
    try:
 
461
        result = TestSuite()
 
462
        result.addTest(tests.test_suite())
 
463
    finally:
 
464
        reload(sys)
 
465
        sys.setdefaultencoding(default_encoding)
 
466
    return result