/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
15
15
"""Graphical support for Bazaar using GTK.
16
16
 
17
17
This plugin includes:
18
 
commit-notify     Start the graphical notifier of commits.
19
18
gannotate         GTK+ annotate. 
20
19
gbranch           GTK+ branching. 
21
20
gcheckout         GTK+ checkout. 
22
 
gcommit           GTK+ commit dialog 
23
 
gconflicts        GTK+ push. 
 
21
gcommit           GTK+ commit dialog.
 
22
gconflicts        GTK+ conflicts. 
24
23
gdiff             Show differences in working tree in a GTK+ Window. 
25
24
ginit             Initialise a new branch.
 
25
gmerge            GTK+ merge dialog
26
26
gmissing          GTK+ missing revisions dialog. 
27
27
gpreferences      GTK+ preferences dialog. 
28
 
gpush             GTK+ push. 
29
 
gstatus           GTK+ status dialog 
 
28
gpush             GTK+ push.
 
29
gsend             GTK+ send merge directive.
 
30
gstatus           GTK+ status dialog.
30
31
gtags             Manage branch tags.
31
32
visualise         Graphically visualise this branch. 
32
33
"""
33
34
 
 
35
import sys
 
36
 
34
37
import bzrlib
35
38
 
36
 
__version__ = '0.19.0'
37
 
version_info = tuple(int(n) for n in __version__.split('.'))
38
 
 
 
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)
39
48
 
40
49
def check_bzrlib_version(desired):
41
50
    """Check that bzrlib is compatible.
42
51
 
43
52
    If version is < bzr-gtk version, assume incompatible.
44
 
    If version == bzr-gtk version, assume completely compatible
45
 
    If version == bzr-gtk version + 1, assume compatible, with deprecations
46
 
    Otherwise, assume incompatible.
47
53
    """
48
 
    desired_plus = (desired[0], desired[1]+1)
49
54
    bzrlib_version = bzrlib.version_info[:2]
50
 
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
51
 
                                     bzrlib.version_info[3] == 'dev'):
52
 
        return
53
55
    try:
54
56
        from bzrlib.trace import warning
55
57
    except ImportError:
57
59
        from warnings import warn as warning
58
60
    if bzrlib_version < desired:
59
61
        from bzrlib.errors import BzrError
60
 
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
 
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
61
63
                ' %s.' % (bzrlib.__version__, __version__))
62
 
        raise BzrError('Version mismatch: %r' % version_info)
63
 
    else:
64
 
        warning('bzr-gtk is not up to date with installed bzr version %s.'
65
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
66
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
67
 
 
68
 
 
69
 
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)
70
69
 
71
70
from bzrlib.trace import warning
72
71
if __name__ != 'bzrlib.plugins.gtk':
76
75
lazy_import(globals(), """
77
76
from bzrlib import (
78
77
    branch,
 
78
    builtins,
79
79
    errors,
 
80
    merge_directive,
80
81
    workingtree,
81
82
    )
82
83
""")
103
104
    bzrlib.ui.ui_factory = GtkUIFactory()
104
105
 
105
106
 
 
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
 
106
136
class GTKCommand(Command):
107
137
    """Abstract class providing GTK specific run commands."""
108
138
 
109
 
    def open_display(self):
110
 
        pygtk = import_pygtk()
111
 
        try:
112
 
            import gtk
113
 
        except RuntimeError, e:
114
 
            if str(e) == "could not open display":
115
 
                raise NoDisplayError
116
 
        set_ui_factory()
117
 
        return gtk
118
 
 
119
139
    def run(self):
120
 
        self.open_display()
 
140
        open_display()
121
141
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
122
142
        dialog.run()
123
143
 
151
171
 
152
172
    def run(self, location="."):
153
173
        (br, path) = branch.Branch.open_containing(location)
154
 
        self.open_display()
 
174
        open_display()
155
175
        from push import PushDialog
156
176
        dialog = PushDialog(br.repository, br.last_revision(), br)
157
177
        dialog.run()
176
196
            if revision is not None:
177
197
                if len(revision) == 1:
178
198
                    tree1 = wt
179
 
                    revision_id = revision[0].in_history(branch).rev_id
 
199
                    revision_id = revision[0].as_revision_id(tree1.branch)
180
200
                    tree2 = branch.repository.revision_tree(revision_id)
181
201
                elif len(revision) == 2:
182
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
202
                    revision_id_0 = revision[0].as_revision_id(branch)
183
203
                    tree2 = branch.repository.revision_tree(revision_id_0)
184
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
204
                    revision_id_1 = revision[1].as_revision_id(branch)
185
205
                    tree1 = branch.repository.revision_tree(revision_id_1)
186
206
            else:
187
207
                tree1 = wt
209
229
            wt.unlock()
210
230
 
211
231
 
212
 
def start_viz_window(branch, revision, limit=None):
 
232
def start_viz_window(branch, revisions, limit=None):
213
233
    """Start viz on branch with revision revision.
214
234
    
215
235
    :return: The viz window object.
216
236
    """
217
 
    from viz.branchwin import BranchWindow
218
 
    branch.lock_read()
219
 
    pp = BranchWindow()
220
 
    pp.set_branch(branch, revision, limit)
221
 
    # cleanup locks when the window is closed
222
 
    pp.connect("destroy", lambda w: branch.unlock())
223
 
    return pp
 
237
    from viz import BranchWindow
 
238
    return BranchWindow(branch, revisions, limit)
224
239
 
225
240
 
226
241
class cmd_visualise(Command):
236
251
        "revision",
237
252
        Option('limit', "Maximum number of revisions to display.",
238
253
               int, 'count')]
239
 
    takes_args = [ "location?" ]
 
254
    takes_args = [ "locations*" ]
240
255
    aliases = [ "visualize", "vis", "viz" ]
241
256
 
242
 
    def run(self, location=".", revision=None, limit=None):
 
257
    def run(self, locations_list, revision=None, limit=None):
243
258
        set_ui_factory()
244
 
        (br, path) = branch.Branch.open_containing(location)
245
 
        br.lock_read()
246
 
        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)
247
264
            if revision is None:
248
 
                revid = br.last_revision()
249
 
                if revid is None:
250
 
                    return
 
265
                revids.append(br.last_revision())
251
266
            else:
252
 
                (revno, revid) = revision[0].in_history(br)
253
 
 
254
 
            import gtk
255
 
            pp = start_viz_window(br, revid, limit)
256
 
            pp.connect("destroy", lambda w: gtk.main_quit())
257
 
            pp.show()
258
 
            gtk.main()
259
 
        finally:
260
 
            br.unlock()
 
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()
261
273
 
262
274
 
263
275
class cmd_gannotate(GTKCommand):
277
289
    aliases = ["gblame", "gpraise"]
278
290
    
279
291
    def run(self, filename, all=False, plain=False, line='1', revision=None):
280
 
        gtk = self.open_display()
 
292
        gtk = open_display()
281
293
 
282
294
        try:
283
295
            line = int(line)
302
314
        if revision is not None:
303
315
            if len(revision) != 1:
304
316
                raise BzrCommandError("Only 1 revion may be specified.")
305
 
            revision_id = revision[0].in_history(br).rev_id
 
317
            revision_id = revision[0].as_revision_id(br)
306
318
            tree = br.repository.revision_tree(revision_id)
307
319
        else:
308
320
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
309
321
 
310
 
        window = GAnnotateWindow(all, plain)
 
322
        window = GAnnotateWindow(all, plain, branch=br)
311
323
        window.connect("destroy", lambda w: gtk.main_quit())
312
 
        window.set_title(path + " - gannotate")
313
324
        config = GAnnotateConfig(window)
314
325
        window.show()
315
326
        br.lock_read()
330
341
    """GTK+ commit dialog
331
342
 
332
343
    Graphical user interface for committing revisions"""
333
 
    
 
344
 
334
345
    aliases = [ "gci" ]
335
346
    takes_args = []
336
347
    takes_options = []
337
348
 
338
349
    def run(self, filename=None):
339
350
        import os
340
 
        self.open_display()
 
351
        open_display()
341
352
        from commit import CommitDialog
342
353
        from bzrlib.errors import (BzrCommandError,
343
354
                                   NotBranchError,
349
360
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
350
361
            br = wt.branch
351
362
        except NoWorkingTree, e:
352
 
            path = e.base
353
 
            (br, path) = branch.Branch.open_containing(path)
354
 
 
355
 
        commit = CommitDialog(wt, path, not br)
356
 
        commit.run()
357
 
 
 
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()
358
378
 
359
379
 
360
380
class cmd_gstatus(GTKCommand):
365
385
    
366
386
    aliases = [ "gst" ]
367
387
    takes_args = ['PATH?']
368
 
    takes_options = []
 
388
    takes_options = ['revision']
369
389
 
370
 
    def run(self, path='.'):
 
390
    def run(self, path='.', revision=None):
371
391
        import os
372
 
        gtk = self.open_display()
 
392
        gtk = open_display()
373
393
        from status import StatusDialog
374
394
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
375
 
        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)
376
406
        status.connect("destroy", gtk.main_quit)
377
407
        status.run()
378
408
 
379
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
 
380
429
 
381
430
class cmd_gconflicts(GTKCommand):
382
 
    """ GTK+ push.
 
431
    """GTK+ conflicts.
383
432
    
 
433
    Select files from the list of conflicts and run an external utility to
 
434
    resolve them.
384
435
    """
385
436
    def run(self):
386
437
        (wt, path) = workingtree.WorkingTree.open_containing('.')
387
 
        self.open_display()
 
438
        open_display()
388
439
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
389
440
        dialog = ConflictsDialog(wt)
390
441
        dialog.run()
391
442
 
392
443
 
393
 
 
394
444
class cmd_gpreferences(GTKCommand):
395
445
    """ GTK+ preferences dialog.
396
446
 
397
447
    """
398
448
    def run(self):
399
 
        self.open_display()
 
449
        open_display()
400
450
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
401
451
        dialog = PreferencesWindow()
402
452
        dialog.run()
403
453
 
404
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
 
405
477
 
406
478
class cmd_gmissing(Command):
407
479
    """ GTK+ missing revisions dialog.
441
513
 
442
514
class cmd_ginit(GTKCommand):
443
515
    def run(self):
444
 
        self.open_display()
 
516
        open_display()
445
517
        from initialize import InitDialog
446
518
        dialog = InitDialog(os.path.abspath(os.path.curdir))
447
519
        dialog.run()
451
523
    def run(self):
452
524
        br = branch.Branch.open_containing('.')[0]
453
525
        
454
 
        gtk = self.open_display()
 
526
        gtk = open_display()
455
527
        from tags import TagsWindow
456
528
        window = TagsWindow(br)
457
529
        window.show()
459
531
 
460
532
 
461
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,
462
542
    cmd_gmissing, 
463
543
    cmd_gpreferences, 
464
 
    cmd_gconflicts, 
 
544
    cmd_gpush, 
 
545
    cmd_gsend,
465
546
    cmd_gstatus,
466
 
    cmd_gcommit, 
467
 
    cmd_gannotate, 
468
 
    cmd_visualise, 
469
 
    cmd_gdiff,
470
 
    cmd_gpush, 
471
 
    cmd_gcheckout, 
472
 
    cmd_gbranch,
473
 
    cmd_ginit,
474
 
    cmd_gtags
 
547
    cmd_gtags,
 
548
    cmd_visualise
475
549
    ]
476
550
 
477
551
for cmd in commands:
478
552
    register_command(cmd)
479
553
 
480
554
 
481
 
class cmd_commit_notify(GTKCommand):
482
 
    """Run the bzr commit notifier.
483
 
 
484
 
    This is a background program which will pop up a notification on the users
485
 
    screen when a commit occurs.
486
 
    """
487
 
 
488
 
    def run(self):
489
 
        from notify import NotifyPopupMenu
490
 
        gtk = self.open_display()
491
 
        menu = NotifyPopupMenu()
492
 
        icon = gtk.status_icon_new_from_file("bzr-icon-64.png")
493
 
        icon.connect('popup-menu', menu.display)
494
 
 
 
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):
495
563
        import cgi
496
 
        import dbus
497
 
        import dbus.service
 
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
498
569
        import pynotify
499
 
        from bzrlib.bzrdir import BzrDir
500
 
        from bzrlib import errors
501
 
        from bzrlib.osutils import format_date
502
 
        from bzrlib.transport import get_transport
503
 
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
504
 
            import dbus.glib
505
 
        from bzrlib.plugins.dbus import activity
506
 
        bus = dbus.SessionBus()
507
 
        # get the object so we can subscribe to callbacks from it.
508
 
        broadcast_service = bus.get_object(
509
 
            activity.Broadcast.DBUS_NAME,
510
 
            activity.Broadcast.DBUS_PATH)
511
 
 
512
 
        def catch_branch(revision_id, urls):
513
 
            # TODO: show all the urls, or perhaps choose the 'best'.
514
 
            url = urls[0]
515
 
            try:
516
 
                if isinstance(revision_id, unicode):
517
 
                    revision_id = revision_id.encode('utf8')
518
 
                transport = get_transport(url)
519
 
                a_dir = BzrDir.open_from_transport(transport)
520
 
                branch = a_dir.open_branch()
521
 
                revno = branch.revision_id_to_revno(revision_id)
522
 
                revision = branch.repository.get_revision(revision_id)
523
 
                summary = 'New revision %d in %s' % (revno, url)
524
 
                body  = 'Committer: %s\n' % revision.committer
525
 
                body += 'Date: %s\n' % format_date(revision.timestamp,
526
 
                    revision.timezone)
527
 
                body += '\n'
528
 
                body += revision.message
529
 
                body = cgi.escape(body)
530
 
                nw = pynotify.Notification(summary, body)
531
 
                def start_viz(notification=None, action=None, data=None):
532
 
                    """Start the viz program."""
533
 
                    pp = start_viz_window(branch, revision_id)
534
 
                    pp.show()
535
 
                def start_branch(notification=None, action=None, data=None):
536
 
                    """Start a Branch dialog"""
537
 
                    from bzrlib.plugins.gtk.branch import BranchDialog
538
 
                    bd = BranchDialog(remote_path=url)
539
 
                    bd.run()
540
 
                nw.add_action("inspect", "Inspect", start_viz, None)
541
 
                nw.add_action("branch", "Branch", start_branch, None)
542
 
                nw.set_timeout(5000)
543
 
                nw.show()
544
 
            except Exception, e:
545
 
                print e
546
 
                raise
547
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
548
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
549
 
        pynotify.init("bzr commit-notify")
550
 
        gtk.main()
551
 
 
552
 
register_command(cmd_commit_notify)
 
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
 
553
650
 
554
651
 
555
652
import gettext
556
653
gettext.install('olive-gtk')
557
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
558
658
 
559
659
class NoDisplayError(BzrCommandError):
560
660
    """gtk could not find a proper display"""
570
670
    default_encoding = sys.getdefaultencoding()
571
671
    try:
572
672
        result = TestSuite()
 
673
        try:
 
674
            import_pygtk()
 
675
        except errors.BzrCommandError:
 
676
            return result
573
677
        result.addTest(tests.test_suite())
574
678
    finally:
575
679
        if sys.getdefaultencoding() != default_encoding: