/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: 2006-09-30 10:21:43 UTC
  • Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.

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
60
17
from bzrlib.commands import Command, register_command, display_command
61
18
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
62
19
from bzrlib.commands import Command, register_command
65
22
from bzrlib.workingtree import WorkingTree
66
23
from bzrlib.bzrdir import BzrDir
67
24
 
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
 
 
 
25
__version__ = '0.11.0'
85
26
 
86
27
class cmd_gbranch(Command):
87
28
    """GTK+ branching.
89
30
    """
90
31
 
91
32
    def run(self):
92
 
        pygtk = import_pygtk()
 
33
        import pygtk
 
34
        pygtk.require("2.0")
93
35
        try:
94
36
            import gtk
95
37
        except RuntimeError, e:
96
38
            if str(e) == "could not open display":
97
39
                raise NoDisplayError
98
40
 
99
 
        from bzrlib.plugins.gtk.branch import BranchDialog
 
41
        from clone import CloneDialog
100
42
 
101
 
        set_ui_factory()
102
 
        dialog = BranchDialog(os.path.abspath('.'))
103
 
        dialog.run()
 
43
        window = CloneDialog()
 
44
        if window.run() == gtk.RESPONSE_OK:
 
45
            bzrdir = BzrDir.open(window.url)
 
46
            bzrdir.sprout(window.dest_path)
104
47
 
105
48
register_command(cmd_gbranch)
106
49
 
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
 
 
152
50
class cmd_gdiff(Command):
153
51
    """Show differences in working tree in a GTK+ Window.
154
52
    
159
57
 
160
58
    @display_command
161
59
    def run(self, revision=None, filename=None):
162
 
        set_ui_factory()
163
60
        wt = WorkingTree.open_containing(".")[0]
164
61
        branch = wt.branch
165
62
        if revision is not None:
176
73
            tree1 = wt
177
74
            tree2 = tree1.basis_tree()
178
75
 
179
 
        from viz.diff import DiffWindow
 
76
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
180
77
        import gtk
181
78
        window = DiffWindow()
182
79
        window.connect("destroy", lambda w: gtk.main_quit())
183
80
        window.set_diff("Working Tree", tree1, tree2)
184
81
        if filename is not None:
185
 
            tree_filename = wt.relpath(filename)
 
82
            tree_filename = tree1.relpath(filename)
186
83
            try:
187
84
                window.set_file(tree_filename)
188
85
            except NoSuchFile:
214
111
    aliases = [ "visualize", "vis", "viz" ]
215
112
 
216
113
    def run(self, location=".", revision=None, limit=None):
217
 
        set_ui_factory()
218
114
        (branch, path) = Branch.open_containing(location)
219
115
        branch.lock_read()
220
116
        branch.repository.lock_read()
249
145
        Option("all", help="show annotations on all lines"),
250
146
        Option("plain", help="don't highlight annotation lines"),
251
147
        Option("line", type=int, argname="lineno",
252
 
               help="jump to specified line number"),
253
 
        "revision",
 
148
               help="jump to specified line number")
254
149
    ]
255
150
    aliases = ["gblame", "gpraise"]
256
151
    
257
 
    def run(self, filename, all=False, plain=False, line='1', revision=None):
258
 
        pygtk = import_pygtk()
 
152
    def run(self, filename, all=False, plain=False, line='1'):
 
153
        import pygtk
 
154
        pygtk.require("2.0")
259
155
 
260
156
        try:
261
157
            import gtk
262
158
        except RuntimeError, e:
263
159
            if str(e) == "could not open display":
264
160
                raise NoDisplayError
265
 
        set_ui_factory()
266
161
 
267
162
        try:
268
163
            line = int(line)
273
168
        from annotate.gannotate import GAnnotateWindow
274
169
        from annotate.config import GAnnotateConfig
275
170
 
276
 
        try:
277
 
            (tree, path) = WorkingTree.open_containing(filename)
278
 
            branch = tree.branch
279
 
        except errors.NoWorkingTree:
280
 
            (branch, path) = Branch.open_containing(filename)
281
 
            tree = branch.basis_tree()
 
171
        (wt, path) = WorkingTree.open_containing(filename)
 
172
        branch = wt.branch
282
173
 
283
 
        file_id = tree.path2id(path)
 
174
        file_id = wt.path2id(path)
284
175
 
285
176
        if file_id is None:
286
177
            raise NotVersionedError(filename)
287
 
        if revision is not None:
288
 
            if len(revision) != 1:
289
 
                raise BzrCommandError("Only 1 revion may be specified.")
290
 
            revision_id = revision[0].in_history(branch).rev_id
291
 
            tree = branch.repository.revision_tree(revision_id)
292
 
        else:
293
 
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
294
178
 
295
179
        window = GAnnotateWindow(all, plain)
296
180
        window.connect("destroy", lambda w: gtk.main_quit())
299
183
        window.show()
300
184
        branch.lock_read()
301
185
        try:
302
 
            window.annotate(tree, branch, file_id)
 
186
            window.annotate(branch, file_id)
303
187
        finally:
304
188
            branch.unlock()
305
189
        window.jump_to_line(line)
313
197
 
314
198
    Graphical user interface for committing revisions"""
315
199
    
316
 
    aliases = [ "gci" ]
317
200
    takes_args = []
318
201
    takes_options = []
319
202
 
320
203
    def run(self, filename=None):
321
 
        import os
322
 
        pygtk = import_pygtk()
 
204
        import pygtk
 
205
        pygtk.require("2.0")
323
206
 
324
207
        try:
325
208
            import gtk
327
210
            if str(e) == "could not open display":
328
211
                raise NoDisplayError
329
212
 
330
 
        set_ui_factory()
331
 
        from commit import CommitDialog
 
213
        from commit import GCommitDialog
332
214
        from bzrlib.commit import Commit
333
 
        from bzrlib.errors import (BzrCommandError,
334
 
                                   NotBranchError,
335
 
                                   NoWorkingTree,
336
 
                                   PointlessCommit,
337
 
                                   ConflictsInTree,
338
 
                                   StrictCommitFailed)
339
 
 
340
 
        wt = None
341
 
        branch = None
342
 
        try:
343
 
            (wt, path) = WorkingTree.open_containing(filename)
344
 
            branch = wt.branch
345
 
        except NotBranchError, e:
346
 
            path = e.path
347
 
        except NoWorkingTree, e:
348
 
            path = e.base
349
 
            try:
350
 
                (branch, path) = Branch.open_containing(path)
351
 
            except NotBranchError, e:
352
 
                path = e.path
353
 
 
354
 
 
355
 
        commit = CommitDialog(wt, path, not branch)
356
 
        commit.run()
 
215
        from bzrlib.errors import (BzrCommandError, PointlessCommit, ConflictsInTree, 
 
216
           StrictCommitFailed)
 
217
 
 
218
        (wt, path) = WorkingTree.open_containing(filename)
 
219
        branch = wt.branch
 
220
 
 
221
        file_id = wt.path2id(path)
 
222
 
 
223
        if file_id is None:
 
224
            raise NotVersionedError(filename)
 
225
 
 
226
        dialog = GCommitDialog(wt)
 
227
        dialog.set_title(path + " - Commit")
 
228
        if dialog.run() != gtk.RESPONSE_CANCEL:
 
229
            Commit().commit(working_tree=wt,message=dialog.message,
 
230
                specific_files=dialog.specific_files)
357
231
 
358
232
register_command(cmd_gcommit)
359
233
 
361
235
    """gtk could not find a proper display"""
362
236
 
363
237
    def __str__(self):
364
 
        return "No DISPLAY. Unable to run GTK+ application."
365
 
 
366
 
def test_suite():
367
 
    from unittest import TestSuite
368
 
    import tests
369
 
    result = TestSuite()
370
 
    result.addTest(tests.test_suite())
371
 
    return result
 
238
        return "No DISPLAY. gannotate is disabled."