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