/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: Jasper Groenewegen
  • Date: 2008-07-27 12:01:40 UTC
  • mfrom: (576.3.2 improve-merge)
  • mto: This revision was merged to the branch mainline in revision 579.
  • Revision ID: colbrac@xs4all.nl-20080727120140-1agdlzkc9fumjk5f
Merge merge dialog improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
12
12
# along with this program; if not, write to the Free Software
13
13
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
14
14
 
15
 
"""GTK+ frontends to Bazaar commands """
 
15
"""Graphical support for Bazaar using GTK.
 
16
 
 
17
This plugin includes:
 
18
gannotate         GTK+ annotate. 
 
19
gbranch           GTK+ branching. 
 
20
gcheckout         GTK+ checkout. 
 
21
gcommit           GTK+ commit dialog.
 
22
gconflicts        GTK+ conflicts. 
 
23
gdiff             Show differences in working tree in a GTK+ Window. 
 
24
ginit             Initialise a new branch.
 
25
gmerge            GTK+ merge dialog
 
26
gmissing          GTK+ missing revisions dialog. 
 
27
gpreferences      GTK+ preferences dialog. 
 
28
gpush             GTK+ push.
 
29
gsend             GTK+ send merge directive.
 
30
gstatus           GTK+ status dialog.
 
31
gtags             Manage branch tags.
 
32
visualise         Graphically visualise this branch. 
 
33
"""
 
34
 
 
35
import sys
16
36
 
17
37
import bzrlib
18
38
 
19
 
__version__ = '0.16.0'
20
 
version_info = tuple(int(n) for n in __version__.split('.'))
21
 
 
 
39
version_info = (0, 95, 0, 'dev', 1)
 
40
 
 
41
if version_info[3] == 'final':
 
42
    version_string = '%d.%d.%d' % version_info[:3]
 
43
else:
 
44
    version_string = '%d.%d.%d%s%d' % version_info
 
45
__version__ = version_string
 
46
 
 
47
required_bzrlib = (1, 3)
22
48
 
23
49
def check_bzrlib_version(desired):
24
50
    """Check that bzrlib is compatible.
25
51
 
26
52
    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
53
    """
31
 
    desired_plus = (desired[0], desired[1]+1)
32
54
    bzrlib_version = bzrlib.version_info[:2]
33
 
    if bzrlib_version == desired:
34
 
        return
35
55
    try:
36
56
        from bzrlib.trace import warning
37
57
    except ImportError:
38
58
        # get the message out any way we can
39
59
        from warnings import warn as warning
40
60
    if bzrlib_version < desired:
41
 
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
 
61
        from bzrlib.errors import BzrError
 
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
42
63
                ' %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])
 
64
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
 
65
 
 
66
 
 
67
if version_info[2] == "final":
 
68
    check_bzrlib_version(required_bzrlib)
54
69
 
55
70
from bzrlib.trace import warning
56
71
if __name__ != 'bzrlib.plugins.gtk':
60
75
lazy_import(globals(), """
61
76
from bzrlib import (
62
77
    branch,
 
78
    builtins,
63
79
    errors,
 
80
    merge_directive,
64
81
    workingtree,
65
82
    )
66
83
""")
67
84
 
68
85
from bzrlib.commands import Command, register_command, display_command
69
86
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
70
 
from bzrlib.commands import Command, register_command
71
87
from bzrlib.option import Option
72
 
from bzrlib.bzrdir import BzrDir
73
88
 
74
89
import os.path
75
90
 
83
98
 
84
99
 
85
100
def set_ui_factory():
86
 
    pygtk = import_pygtk()
 
101
    import_pygtk()
87
102
    from ui import GtkUIFactory
88
103
    import bzrlib.ui
89
104
    bzrlib.ui.ui_factory = GtkUIFactory()
90
105
 
91
106
 
92
 
class cmd_gbranch(Command):
 
107
def data_basedirs():
 
108
    return [os.path.dirname(__file__),
 
109
             "/usr/share/bzr-gtk", 
 
110
             "/usr/local/share/bzr-gtk"]
 
111
 
 
112
 
 
113
def data_path(*args):
 
114
    for basedir in data_basedirs():
 
115
        path = os.path.join(basedir, *args)
 
116
        if os.path.exists(path):
 
117
            return path
 
118
    return None
 
119
 
 
120
 
 
121
def icon_path(*args):
 
122
    return data_path(os.path.join('icons', *args))
 
123
 
 
124
 
 
125
def open_display():
 
126
    pygtk = import_pygtk()
 
127
    try:
 
128
        import gtk
 
129
    except RuntimeError, e:
 
130
        if str(e) == "could not open display":
 
131
            raise NoDisplayError
 
132
    set_ui_factory()
 
133
    return gtk
 
134
 
 
135
 
 
136
class GTKCommand(Command):
 
137
    """Abstract class providing GTK specific run commands."""
 
138
 
 
139
    def run(self):
 
140
        open_display()
 
141
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
 
142
        dialog.run()
 
143
 
 
144
 
 
145
class cmd_gbranch(GTKCommand):
93
146
    """GTK+ branching.
94
147
    
95
148
    """
96
149
 
97
 
    def run(self):
98
 
        pygtk = import_pygtk()
99
 
        try:
100
 
            import gtk
101
 
        except RuntimeError, e:
102
 
            if str(e) == "could not open display":
103
 
                raise NoDisplayError
104
 
 
 
150
    def get_gtk_dialog(self, path):
105
151
        from bzrlib.plugins.gtk.branch import BranchDialog
106
 
 
107
 
        set_ui_factory()
108
 
        dialog = BranchDialog(os.path.abspath('.'))
109
 
        dialog.run()
110
 
 
111
 
register_command(cmd_gbranch)
112
 
 
113
 
class cmd_gcheckout(Command):
 
152
        return BranchDialog(path)
 
153
 
 
154
 
 
155
class cmd_gcheckout(GTKCommand):
114
156
    """ GTK+ checkout.
115
157
    
116
158
    """
117
159
    
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
 
 
 
160
    def get_gtk_dialog(self, path):
126
161
        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):
 
162
        return CheckoutDialog(path)
 
163
 
 
164
 
 
165
 
 
166
class cmd_gpush(GTKCommand):
135
167
    """ GTK+ push.
136
168
    
137
169
    """
139
171
 
140
172
    def run(self, location="."):
141
173
        (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
 
 
 
174
        open_display()
150
175
        from push import PushDialog
151
 
 
152
 
        set_ui_factory()
153
 
        dialog = PushDialog(br)
 
176
        dialog = PushDialog(br.repository, br.last_revision(), br)
154
177
        dialog.run()
155
178
 
156
 
register_command(cmd_gpush)
157
 
 
158
 
class cmd_gdiff(Command):
 
179
 
 
180
 
 
181
class cmd_gdiff(GTKCommand):
159
182
    """Show differences in working tree in a GTK+ Window.
160
183
    
161
184
    Otherwise, all changes for the tree are listed.
173
196
            if revision is not None:
174
197
                if len(revision) == 1:
175
198
                    tree1 = wt
176
 
                    revision_id = revision[0].in_history(branch).rev_id
 
199
                    revision_id = revision[0].as_revision_id(tree1.branch)
177
200
                    tree2 = branch.repository.revision_tree(revision_id)
178
201
                elif len(revision) == 2:
179
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
202
                    revision_id_0 = revision[0].as_revision_id(branch)
180
203
                    tree2 = branch.repository.revision_tree(revision_id_0)
181
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
204
                    revision_id_1 = revision[1].as_revision_id(branch)
182
205
                    tree1 = branch.repository.revision_tree(revision_id_1)
183
206
            else:
184
207
                tree1 = wt
194
217
                try:
195
218
                    window.set_file(tree_filename)
196
219
                except NoSuchFile:
197
 
                    if (tree1.inventory.path2id(tree_filename) is None and 
198
 
                        tree2.inventory.path2id(tree_filename) is None):
 
220
                    if (tree1.path2id(tree_filename) is None and 
 
221
                        tree2.path2id(tree_filename) is None):
199
222
                        raise NotVersionedError(filename)
200
223
                    raise BzrCommandError('No changes found for file "%s"' % 
201
224
                                          filename)
205
228
        finally:
206
229
            wt.unlock()
207
230
 
208
 
register_command(cmd_gdiff)
 
231
 
 
232
def start_viz_window(branch, revisions, limit=None):
 
233
    """Start viz on branch with revision revision.
 
234
    
 
235
    :return: The viz window object.
 
236
    """
 
237
    from viz import BranchWindow
 
238
    return BranchWindow(branch, revisions, limit)
 
239
 
209
240
 
210
241
class cmd_visualise(Command):
211
242
    """Graphically visualise this branch.
218
249
    """
219
250
    takes_options = [
220
251
        "revision",
221
 
        Option('limit', "maximum number of revisions to display",
 
252
        Option('limit', "Maximum number of revisions to display.",
222
253
               int, 'count')]
223
 
    takes_args = [ "location?" ]
 
254
    takes_args = [ "locations*" ]
224
255
    aliases = [ "visualize", "vis", "viz" ]
225
256
 
226
 
    def run(self, location=".", revision=None, limit=None):
 
257
    def run(self, locations_list, revision=None, limit=None):
227
258
        set_ui_factory()
228
 
        (br, path) = branch.Branch.open_containing(location)
229
 
        br.lock_read()
230
 
        br.repository.lock_read()
231
 
        try:
 
259
        if locations_list is None:
 
260
            locations_list = ["."]
 
261
        revids = []
 
262
        for location in locations_list:
 
263
            (br, path) = branch.Branch.open_containing(location)
232
264
            if revision is None:
233
 
                revid = br.last_revision()
234
 
                if revid is None:
235
 
                    return
 
265
                revids.append(br.last_revision())
236
266
            else:
237
 
                (revno, revid) = revision[0].in_history(br)
238
 
 
239
 
            from viz.branchwin import BranchWindow
240
 
            import gtk
241
 
                
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()
247
 
        finally:
248
 
            br.repository.unlock()
249
 
            br.unlock()
250
 
 
251
 
 
252
 
register_command(cmd_visualise)
253
 
 
254
 
class cmd_gannotate(Command):
 
267
                revids.append(revision[0].as_revision_id(br))
 
268
        import gtk
 
269
        pp = start_viz_window(br, revids, limit)
 
270
        pp.connect("destroy", lambda w: gtk.main_quit())
 
271
        pp.show()
 
272
        gtk.main()
 
273
 
 
274
 
 
275
class cmd_gannotate(GTKCommand):
255
276
    """GTK+ annotate.
256
277
    
257
278
    Browse changes to FILENAME line by line in a GTK+ window.
259
280
 
260
281
    takes_args = ["filename", "line?"]
261
282
    takes_options = [
262
 
        Option("all", help="show annotations on all lines"),
263
 
        Option("plain", help="don't highlight annotation lines"),
 
283
        Option("all", help="Show annotations on all lines."),
 
284
        Option("plain", help="Don't highlight annotation lines."),
264
285
        Option("line", type=int, argname="lineno",
265
 
               help="jump to specified line number"),
 
286
               help="Jump to specified line number."),
266
287
        "revision",
267
288
    ]
268
289
    aliases = ["gblame", "gpraise"]
269
290
    
270
291
    def run(self, filename, all=False, plain=False, line='1', revision=None):
271
 
        pygtk = import_pygtk()
272
 
 
273
 
        try:
274
 
            import gtk
275
 
        except RuntimeError, e:
276
 
            if str(e) == "could not open display":
277
 
                raise NoDisplayError
278
 
        set_ui_factory()
 
292
        gtk = open_display()
279
293
 
280
294
        try:
281
295
            line = int(line)
285
299
 
286
300
        from annotate.gannotate import GAnnotateWindow
287
301
        from annotate.config import GAnnotateConfig
 
302
        from bzrlib.bzrdir import BzrDir
288
303
 
289
304
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
290
305
        if wt is not None:
299
314
        if revision is not None:
300
315
            if len(revision) != 1:
301
316
                raise BzrCommandError("Only 1 revion may be specified.")
302
 
            revision_id = revision[0].in_history(br).rev_id
 
317
            revision_id = revision[0].as_revision_id(br)
303
318
            tree = br.repository.revision_tree(revision_id)
304
319
        else:
305
320
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
306
321
 
307
 
        window = GAnnotateWindow(all, plain)
 
322
        window = GAnnotateWindow(all, plain, branch=br)
308
323
        window.connect("destroy", lambda w: gtk.main_quit())
309
 
        window.set_title(path + " - gannotate")
310
324
        config = GAnnotateConfig(window)
311
325
        window.show()
312
326
        br.lock_read()
321
335
            if wt is not None:
322
336
                wt.unlock()
323
337
 
324
 
register_command(cmd_gannotate)
325
 
 
326
 
class cmd_gcommit(Command):
 
338
 
 
339
 
 
340
class cmd_gcommit(GTKCommand):
327
341
    """GTK+ commit dialog
328
342
 
329
343
    Graphical user interface for committing revisions"""
330
 
    
 
344
 
331
345
    aliases = [ "gci" ]
332
346
    takes_args = []
333
347
    takes_options = []
334
348
 
335
349
    def run(self, filename=None):
336
350
        import os
337
 
        pygtk = import_pygtk()
338
 
 
339
 
        try:
340
 
            import gtk
341
 
        except RuntimeError, e:
342
 
            if str(e) == "could not open display":
343
 
                raise NoDisplayError
344
 
 
345
 
        set_ui_factory()
 
351
        open_display()
346
352
        from commit import CommitDialog
347
 
        from bzrlib.commit import Commit
348
353
        from bzrlib.errors import (BzrCommandError,
349
354
                                   NotBranchError,
350
 
                                   NoWorkingTree,
351
 
                                   PointlessCommit,
352
 
                                   ConflictsInTree,
353
 
                                   StrictCommitFailed)
 
355
                                   NoWorkingTree)
354
356
 
355
357
        wt = None
356
358
        br = None
357
359
        try:
358
360
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
359
361
            br = wt.branch
360
 
        except NotBranchError, e:
361
 
            path = e.path
362
362
        except NoWorkingTree, e:
363
 
            path = e.base
364
 
            try:
365
 
                (br, path) = branch.Branch.open_containing(path)
366
 
            except NotBranchError, e:
367
 
                path = e.path
368
 
 
369
 
 
370
 
        commit = CommitDialog(wt, path, not br)
371
 
        commit.run()
372
 
 
373
 
register_command(cmd_gcommit)
374
 
 
375
 
class cmd_gstatus(Command):
 
363
            from dialog import error_dialog
 
364
            error_dialog(_i18n('Directory does not have a working tree'),
 
365
                         _i18n('Operation aborted.'))
 
366
            return 1 # should this be retval=3?
 
367
 
 
368
        # It is a good habit to keep things locked for the duration, but it
 
369
        # could cause difficulties if someone wants to do things in another
 
370
        # window... We could lock_read() until we actually go to commit
 
371
        # changes... Just a thought.
 
372
        wt.lock_write()
 
373
        try:
 
374
            dlg = CommitDialog(wt)
 
375
            return dlg.run()
 
376
        finally:
 
377
            wt.unlock()
 
378
 
 
379
 
 
380
class cmd_gstatus(GTKCommand):
376
381
    """GTK+ status dialog
377
382
 
378
383
    Graphical user interface for showing status 
380
385
    
381
386
    aliases = [ "gst" ]
382
387
    takes_args = ['PATH?']
383
 
    takes_options = []
 
388
    takes_options = ['revision']
384
389
 
385
 
    def run(self, path='.'):
 
390
    def run(self, path='.', revision=None):
386
391
        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()
 
392
        gtk = open_display()
396
393
        from status import StatusDialog
397
394
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
398
 
        status = StatusDialog(wt, wt_path)
 
395
        
 
396
        if revision is not None:
 
397
            try:
 
398
                revision_id = revision[0].as_revision_id(wt.branch)
 
399
            except:
 
400
                from bzrlib.errors import BzrError
 
401
                raise BzrError('Revision %r doesn\'t exist' % revision[0].user_spec )
 
402
        else:
 
403
            revision_id = None
 
404
 
 
405
        status = StatusDialog(wt, wt_path, revision_id)
399
406
        status.connect("destroy", gtk.main_quit)
400
407
        status.run()
401
408
 
402
 
register_command(cmd_gstatus)
403
 
 
404
 
class cmd_gconflicts(Command):
405
 
    """ GTK+ push.
 
409
 
 
410
class cmd_gsend(GTKCommand):
 
411
    """GTK+ send merge directive.
 
412
 
 
413
    """
 
414
    def run(self):
 
415
        (br, path) = branch.Branch.open_containing(".")
 
416
        gtk = open_display()
 
417
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
418
        from StringIO import StringIO
 
419
        dialog = SendMergeDirectiveDialog(br)
 
420
        if dialog.run() == gtk.RESPONSE_OK:
 
421
            outf = StringIO()
 
422
            outf.writelines(dialog.get_merge_directive().to_lines())
 
423
            mail_client = br.get_config().get_mail_client()
 
424
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
425
                outf.getvalue())
 
426
 
 
427
            
 
428
 
 
429
 
 
430
class cmd_gconflicts(GTKCommand):
 
431
    """GTK+ conflicts.
406
432
    
 
433
    Select files from the list of conflicts and run an external utility to
 
434
    resolve them.
407
435
    """
408
436
    def run(self):
409
437
        (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
 
 
 
438
        open_display()
418
439
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
419
 
 
420
 
        set_ui_factory()
421
440
        dialog = ConflictsDialog(wt)
422
441
        dialog.run()
423
442
 
424
 
register_command(cmd_gconflicts)
 
443
 
 
444
class cmd_gpreferences(GTKCommand):
 
445
    """ GTK+ preferences dialog.
 
446
 
 
447
    """
 
448
    def run(self):
 
449
        open_display()
 
450
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
 
451
        dialog = PreferencesWindow()
 
452
        dialog.run()
 
453
 
 
454
 
 
455
class cmd_gmerge(Command):
 
456
    """ GTK+ merge dialog
 
457
    
 
458
    """
 
459
    takes_args = ["merge_from_path?"]
 
460
    def run(self, merge_from_path=None):
 
461
        from bzrlib import workingtree
 
462
        from bzrlib.plugins.gtk.dialog import error_dialog
 
463
        from bzrlib.plugins.gtk.merge import MergeDialog
 
464
        
 
465
        (wt, path) = workingtree.WorkingTree.open_containing('.')
 
466
        old_tree = wt.branch.repository.revision_tree(wt.branch.last_revision())
 
467
        delta = wt.changes_from(old_tree)
 
468
        if len(delta.added) or len(delta.removed) or len(delta.renamed) or len(delta.modified):
 
469
            error_dialog(_i18n('There are local changes in the branch'),
 
470
                         _i18n('Please commit or revert the changes before merging.'))
 
471
        else:
 
472
            parent_branch_path = wt.branch.get_parent()
 
473
            merge = MergeDialog(wt, path, parent_branch_path)
 
474
            response = merge.run()
 
475
            merge.destroy()
 
476
 
 
477
 
 
478
class cmd_gmissing(Command):
 
479
    """ GTK+ missing revisions dialog.
 
480
 
 
481
    """
 
482
    takes_args = ["other_branch?"]
 
483
    def run(self, other_branch=None):
 
484
        pygtk = import_pygtk()
 
485
        try:
 
486
            import gtk
 
487
        except RuntimeError, e:
 
488
            if str(e) == "could not open display":
 
489
                raise NoDisplayError
 
490
 
 
491
        from bzrlib.plugins.gtk.missing import MissingWindow
 
492
        from bzrlib.branch import Branch
 
493
 
 
494
        local_branch = Branch.open_containing(".")[0]
 
495
        if other_branch is None:
 
496
            other_branch = local_branch.get_parent()
 
497
            
 
498
            if other_branch is None:
 
499
                raise errors.BzrCommandError("No peer location known or specified.")
 
500
        remote_branch = Branch.open_containing(other_branch)[0]
 
501
        set_ui_factory()
 
502
        local_branch.lock_read()
 
503
        try:
 
504
            remote_branch.lock_read()
 
505
            try:
 
506
                dialog = MissingWindow(local_branch, remote_branch)
 
507
                dialog.run()
 
508
            finally:
 
509
                remote_branch.unlock()
 
510
        finally:
 
511
            local_branch.unlock()
 
512
 
 
513
 
 
514
class cmd_ginit(GTKCommand):
 
515
    def run(self):
 
516
        open_display()
 
517
        from initialize import InitDialog
 
518
        dialog = InitDialog(os.path.abspath(os.path.curdir))
 
519
        dialog.run()
 
520
 
 
521
 
 
522
class cmd_gtags(GTKCommand):
 
523
    def run(self):
 
524
        br = branch.Branch.open_containing('.')[0]
 
525
        
 
526
        gtk = open_display()
 
527
        from tags import TagsWindow
 
528
        window = TagsWindow(br)
 
529
        window.show()
 
530
        gtk.main()
 
531
 
 
532
 
 
533
commands = [
 
534
    cmd_gannotate, 
 
535
    cmd_gbranch,
 
536
    cmd_gcheckout, 
 
537
    cmd_gcommit, 
 
538
    cmd_gconflicts, 
 
539
    cmd_gdiff,
 
540
    cmd_ginit,
 
541
    cmd_gmerge,
 
542
    cmd_gmissing, 
 
543
    cmd_gpreferences, 
 
544
    cmd_gpush, 
 
545
    cmd_gsend,
 
546
    cmd_gstatus,
 
547
    cmd_gtags,
 
548
    cmd_visualise
 
549
    ]
 
550
 
 
551
for cmd in commands:
 
552
    register_command(cmd)
 
553
 
 
554
 
 
555
class cmd_gselftest(GTKCommand):
 
556
    """Version of selftest that displays a notification at the end"""
 
557
 
 
558
    takes_args = builtins.cmd_selftest.takes_args
 
559
    takes_options = builtins.cmd_selftest.takes_options
 
560
    _see_also = ['selftest']
 
561
 
 
562
    def run(self, *args, **kwargs):
 
563
        import cgi
 
564
        import sys
 
565
        default_encoding = sys.getdefaultencoding()
 
566
        # prevent gtk from blowing up later
 
567
        gtk = import_pygtk()
 
568
        # prevent gtk from messing with default encoding
 
569
        import pynotify
 
570
        if sys.getdefaultencoding() != default_encoding:
 
571
            reload(sys)
 
572
            sys.setdefaultencoding(default_encoding)
 
573
        result = builtins.cmd_selftest().run(*args, **kwargs)
 
574
        if result == 0:
 
575
            summary = 'Success'
 
576
            body = 'Selftest succeeded in "%s"' % os.getcwd()
 
577
        if result == 1:
 
578
            summary = 'Failure'
 
579
            body = 'Selftest failed in "%s"' % os.getcwd()
 
580
        pynotify.init("bzr gselftest")
 
581
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
 
582
        note.set_timeout(pynotify.EXPIRES_NEVER)
 
583
        note.show()
 
584
 
 
585
 
 
586
register_command(cmd_gselftest)
 
587
 
 
588
 
 
589
class cmd_test_gtk(GTKCommand):
 
590
    """Version of selftest that just runs the gtk test suite."""
 
591
 
 
592
    takes_options = ['verbose',
 
593
                     Option('one', short_name='1',
 
594
                            help='Stop when one test fails.'),
 
595
                     Option('benchmark', help='Run the benchmarks.'),
 
596
                     Option('lsprof-timed',
 
597
                     help='Generate lsprof output for benchmarked'
 
598
                          ' sections of code.'),
 
599
                     Option('list-only',
 
600
                     help='List the tests instead of running them.'),
 
601
                     Option('randomize', type=str, argname="SEED",
 
602
                     help='Randomize the order of tests using the given'
 
603
                          ' seed or "now" for the current time.'),
 
604
                    ]
 
605
    takes_args = ['testspecs*']
 
606
 
 
607
    def run(self, verbose=None, one=False, benchmark=None,
 
608
            lsprof_timed=None, list_only=False, randomize=None,
 
609
            testspecs_list=None):
 
610
        from bzrlib import __path__ as bzrlib_path
 
611
        from bzrlib.tests import selftest
 
612
 
 
613
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
614
        if benchmark:
 
615
            print 'No benchmarks yet'
 
616
            return 3
 
617
 
 
618
            test_suite_factory = bench_suite
 
619
            if verbose is None:
 
620
                verbose = True
 
621
            # TODO: should possibly lock the history file...
 
622
            benchfile = open(".perf_history", "at", buffering=1)
 
623
        else:
 
624
            test_suite_factory = test_suite
 
625
            if verbose is None:
 
626
                verbose = False
 
627
            benchfile = None
 
628
 
 
629
        if testspecs_list is not None:
 
630
            pattern = '|'.join(testspecs_list)
 
631
        else:
 
632
            pattern = ".*"
 
633
 
 
634
        try:
 
635
            result = selftest(verbose=verbose,
 
636
                              pattern=pattern,
 
637
                              stop_on_failure=one,
 
638
                              test_suite_factory=test_suite_factory,
 
639
                              lsprof_timed=lsprof_timed,
 
640
                              bench_history=benchfile,
 
641
                              list_only=list_only,
 
642
                              random_seed=randomize,
 
643
                             )
 
644
        finally:
 
645
            if benchfile is not None:
 
646
                benchfile.close()
 
647
 
 
648
register_command(cmd_test_gtk)
 
649
 
 
650
 
425
651
 
426
652
import gettext
427
653
gettext.install('olive-gtk')
428
654
 
 
655
# Let's create a specialized alias to protect '_' from being erased by other
 
656
# uses of '_' as an anonymous variable (think pdb for one).
 
657
_i18n = gettext.gettext
 
658
 
429
659
class NoDisplayError(BzrCommandError):
430
660
    """gtk could not find a proper display"""
431
661
 
432
662
    def __str__(self):
433
663
        return "No DISPLAY. Unable to run GTK+ application."
434
664
 
 
665
 
435
666
def test_suite():
436
667
    from unittest import TestSuite
437
668
    import tests
439
670
    default_encoding = sys.getdefaultencoding()
440
671
    try:
441
672
        result = TestSuite()
 
673
        try:
 
674
            import_pygtk()
 
675
        except errors.BzrCommandError:
 
676
            return result
442
677
        result.addTest(tests.test_suite())
443
678
    finally:
444
 
        reload(sys)
445
 
        sys.setdefaultencoding(default_encoding)
 
679
        if sys.getdefaultencoding() != default_encoding:
 
680
            reload(sys)
 
681
            sys.setdefaultencoding(default_encoding)
446
682
    return result