/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Jelmer Vernooij
  • Date: 2007-07-13 23:09:47 UTC
  • Revision ID: jelmer@samba.org-20070713230947-0bngzxibg52vhmjo
Move olive about dialog into olive.

Show diffs side-by-side

added added

removed removed

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