/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: Robert Collins
  • Date: 2007-07-07 22:02:45 UTC
  • mto: This revision was merged to the branch mainline in revision 216.
  • Revision ID: robertc@robertcollins.net-20070707220245-rqbiv4nerkk7z9oc
Add a Branch button to commit-notify.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
19
19
gannotate         GTK+ annotate. 
20
20
gbranch           GTK+ branching. 
21
21
gcheckout         GTK+ checkout. 
22
 
gcommit           GTK+ commit dialog.
23
 
gconflicts        GTK+ conflicts. 
 
22
gcommit           GTK+ commit dialog 
 
23
gconflicts        GTK+ push. 
24
24
gdiff             Show differences in working tree in a GTK+ Window. 
25
25
ginit             Initialise a new branch.
26
26
gmissing          GTK+ missing revisions dialog. 
27
27
gpreferences      GTK+ preferences dialog. 
28
 
gpush             GTK+ push.
29
 
gsend             GTK+ send merge directive.
30
 
gstatus           GTK+ status dialog.
 
28
gpush             GTK+ push. 
 
29
gstatus           GTK+ status dialog 
31
30
gtags             Manage branch tags.
32
31
visualise         Graphically visualise this branch. 
33
32
"""
34
33
 
35
 
import sys
36
 
 
37
34
import bzrlib
38
35
 
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)
 
36
__version__ = '0.17.0'
 
37
version_info = tuple(int(n) for n in __version__.split('.'))
 
38
 
48
39
 
49
40
def check_bzrlib_version(desired):
50
41
    """Check that bzrlib is compatible.
51
42
 
52
43
    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.
53
47
    """
 
48
    desired_plus = (desired[0], desired[1]+1)
54
49
    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
55
53
    try:
56
54
        from bzrlib.trace import warning
57
55
    except ImportError:
59
57
        from warnings import warn as warning
60
58
    if bzrlib_version < desired:
61
59
        from bzrlib.errors import BzrError
62
 
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
 
60
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
63
61
                ' %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)
 
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
        if bzrlib_version != desired_plus:
 
68
            raise Exception, 'Version mismatch'
 
69
 
 
70
 
 
71
check_bzrlib_version(version_info[:2])
69
72
 
70
73
from bzrlib.trace import warning
71
74
if __name__ != 'bzrlib.plugins.gtk':
75
78
lazy_import(globals(), """
76
79
from bzrlib import (
77
80
    branch,
78
 
    builtins,
79
81
    errors,
80
 
    merge_directive,
81
82
    workingtree,
82
83
    )
83
84
""")
104
105
    bzrlib.ui.ui_factory = GtkUIFactory()
105
106
 
106
107
 
107
 
def data_path():
108
 
    return os.path.dirname(__file__)
109
 
 
110
 
 
111
 
def icon_path(*args):
112
 
    basedirs = [os.path.join(data_path()),
113
 
             "/usr/share/bzr-gtk", 
114
 
             "/usr/local/share/bzr-gtk"]
115
 
    for basedir in basedirs:
116
 
        path = os.path.join(basedir, 'icons', *args)
117
 
        if os.path.exists(path):
118
 
            return path
119
 
    return None
120
 
 
121
 
 
122
 
def open_display():
123
 
    pygtk = import_pygtk()
124
 
    try:
125
 
        import gtk
126
 
    except RuntimeError, e:
127
 
        if str(e) == "could not open display":
128
 
            raise NoDisplayError
129
 
    set_ui_factory()
130
 
    return gtk
131
 
 
132
 
 
133
108
class GTKCommand(Command):
134
109
    """Abstract class providing GTK specific run commands."""
135
110
 
 
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
 
136
121
    def run(self):
137
 
        open_display()
 
122
        self.open_display()
138
123
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
139
124
        dialog.run()
140
125
 
168
153
 
169
154
    def run(self, location="."):
170
155
        (br, path) = branch.Branch.open_containing(location)
171
 
        open_display()
 
156
        self.open_display()
172
157
        from push import PushDialog
173
 
        dialog = PushDialog(br.repository, br.last_revision(), br)
 
158
        dialog = PushDialog(br)
174
159
        dialog.run()
175
160
 
176
161
 
193
178
            if revision is not None:
194
179
                if len(revision) == 1:
195
180
                    tree1 = wt
196
 
                    revision_id = revision[0].as_revision_id(tree1.branch)
 
181
                    revision_id = revision[0].in_history(branch).rev_id
197
182
                    tree2 = branch.repository.revision_tree(revision_id)
198
183
                elif len(revision) == 2:
199
 
                    revision_id_0 = revision[0].as_revision_id(branch)
 
184
                    revision_id_0 = revision[0].in_history(branch).rev_id
200
185
                    tree2 = branch.repository.revision_tree(revision_id_0)
201
 
                    revision_id_1 = revision[1].as_revision_id(branch)
 
186
                    revision_id_1 = revision[1].in_history(branch).rev_id
202
187
                    tree1 = branch.repository.revision_tree(revision_id_1)
203
188
            else:
204
189
                tree1 = wt
226
211
            wt.unlock()
227
212
 
228
213
 
229
 
def start_viz_window(branch, revisions, limit=None):
 
214
def start_viz_window(branch, revision, limit=None):
230
215
    """Start viz on branch with revision revision.
231
216
    
232
217
    :return: The viz window object.
233
218
    """
234
 
    from viz import BranchWindow
235
 
    return BranchWindow(branch, revisions, limit)
 
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
236
226
 
237
227
 
238
228
class cmd_visualise(Command):
246
236
    """
247
237
    takes_options = [
248
238
        "revision",
249
 
        Option('limit', "Maximum number of revisions to display.",
 
239
        Option('limit', "maximum number of revisions to display",
250
240
               int, 'count')]
251
 
    takes_args = [ "locations*" ]
 
241
    takes_args = [ "location?" ]
252
242
    aliases = [ "visualize", "vis", "viz" ]
253
243
 
254
 
    def run(self, locations_list, revision=None, limit=None):
 
244
    def run(self, location=".", revision=None, limit=None):
255
245
        set_ui_factory()
256
 
        if locations_list is None:
257
 
            locations_list = ["."]
258
 
        revids = []
259
 
        for location in locations_list:
260
 
            (br, path) = branch.Branch.open_containing(location)
 
246
        (br, path) = branch.Branch.open_containing(location)
 
247
        br.lock_read()
 
248
        try:
261
249
            if revision is None:
262
 
                revids.append(br.last_revision())
 
250
                revid = br.last_revision()
 
251
                if revid is None:
 
252
                    return
263
253
            else:
264
 
                revids.append(revision[0].as_revision_id(br))
265
 
        import gtk
266
 
        pp = start_viz_window(br, revids, limit)
267
 
        pp.connect("destroy", lambda w: gtk.main_quit())
268
 
        pp.show()
269
 
        gtk.main()
 
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()
270
263
 
271
264
 
272
265
class cmd_gannotate(GTKCommand):
277
270
 
278
271
    takes_args = ["filename", "line?"]
279
272
    takes_options = [
280
 
        Option("all", help="Show annotations on all lines."),
281
 
        Option("plain", help="Don't highlight annotation lines."),
 
273
        Option("all", help="show annotations on all lines"),
 
274
        Option("plain", help="don't highlight annotation lines"),
282
275
        Option("line", type=int, argname="lineno",
283
 
               help="Jump to specified line number."),
 
276
               help="jump to specified line number"),
284
277
        "revision",
285
278
    ]
286
279
    aliases = ["gblame", "gpraise"]
287
280
    
288
281
    def run(self, filename, all=False, plain=False, line='1', revision=None):
289
 
        gtk = open_display()
 
282
        gtk = self.open_display()
290
283
 
291
284
        try:
292
285
            line = int(line)
311
304
        if revision is not None:
312
305
            if len(revision) != 1:
313
306
                raise BzrCommandError("Only 1 revion may be specified.")
314
 
            revision_id = revision[0].as_revision_id(br)
 
307
            revision_id = revision[0].in_history(br).rev_id
315
308
            tree = br.repository.revision_tree(revision_id)
316
309
        else:
317
310
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
318
311
 
319
 
        window = GAnnotateWindow(all, plain, branch=br)
 
312
        window = GAnnotateWindow(all, plain)
320
313
        window.connect("destroy", lambda w: gtk.main_quit())
 
314
        window.set_title(path + " - gannotate")
321
315
        config = GAnnotateConfig(window)
322
316
        window.show()
323
317
        br.lock_read()
338
332
    """GTK+ commit dialog
339
333
 
340
334
    Graphical user interface for committing revisions"""
341
 
 
 
335
    
342
336
    aliases = [ "gci" ]
343
337
    takes_args = []
344
338
    takes_options = []
345
339
 
346
340
    def run(self, filename=None):
347
341
        import os
348
 
        open_display()
 
342
        self.open_display()
349
343
        from commit import CommitDialog
350
344
        from bzrlib.errors import (BzrCommandError,
351
345
                                   NotBranchError,
357
351
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
358
352
            br = wt.branch
359
353
        except NoWorkingTree, e:
360
 
            from dialog import error_dialog
361
 
            error_dialog(_i18n('Directory does not have a working tree'),
362
 
                         _i18n('Operation aborted.'))
363
 
            return 1 # should this be retval=3?
364
 
 
365
 
        # It is a good habit to keep things locked for the duration, but it
366
 
        # could cause difficulties if someone wants to do things in another
367
 
        # window... We could lock_read() until we actually go to commit
368
 
        # changes... Just a thought.
369
 
        wt.lock_write()
370
 
        try:
371
 
            dlg = CommitDialog(wt)
372
 
            return dlg.run()
373
 
        finally:
374
 
            wt.unlock()
 
354
            path = e.base
 
355
            (br, path) = branch.Branch.open_containing(path)
 
356
 
 
357
        commit = CommitDialog(wt, path, not br)
 
358
        commit.run()
 
359
 
375
360
 
376
361
 
377
362
class cmd_gstatus(GTKCommand):
382
367
    
383
368
    aliases = [ "gst" ]
384
369
    takes_args = ['PATH?']
385
 
    takes_options = ['revision']
 
370
    takes_options = []
386
371
 
387
 
    def run(self, path='.', revision=None):
 
372
    def run(self, path='.'):
388
373
        import os
389
 
        gtk = open_display()
 
374
        gtk = self.open_display()
390
375
        from status import StatusDialog
391
376
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
392
 
        
393
 
        if revision is not None:
394
 
            try:
395
 
                revision_id = revision[0].as_revision_id(wt.branch)
396
 
            except:
397
 
                from bzrlib.errors import BzrError
398
 
                raise BzrError('Revision %r doesn\'t exist' % revision[0].user_spec )
399
 
        else:
400
 
            revision_id = None
401
 
 
402
 
        status = StatusDialog(wt, wt_path, revision_id)
 
377
        status = StatusDialog(wt, wt_path)
403
378
        status.connect("destroy", gtk.main_quit)
404
379
        status.run()
405
380
 
406
381
 
407
 
class cmd_gsend(GTKCommand):
408
 
    """GTK+ send merge directive.
409
 
 
410
 
    """
411
 
    def run(self):
412
 
        (br, path) = branch.Branch.open_containing(".")
413
 
        gtk = open_display()
414
 
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
415
 
        from StringIO import StringIO
416
 
        dialog = SendMergeDirectiveDialog(br)
417
 
        if dialog.run() == gtk.RESPONSE_OK:
418
 
            outf = StringIO()
419
 
            outf.writelines(dialog.get_merge_directive().to_lines())
420
 
            mail_client = br.get_config().get_mail_client()
421
 
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
422
 
                outf.getvalue())
423
 
 
424
 
            
425
 
 
426
382
 
427
383
class cmd_gconflicts(GTKCommand):
428
 
    """GTK+ conflicts.
 
384
    """ GTK+ push.
429
385
    
430
 
    Select files from the list of conflicts and run an external utility to
431
 
    resolve them.
432
386
    """
433
387
    def run(self):
434
388
        (wt, path) = workingtree.WorkingTree.open_containing('.')
435
 
        open_display()
 
389
        self.open_display()
436
390
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
437
391
        dialog = ConflictsDialog(wt)
438
392
        dialog.run()
439
393
 
440
394
 
 
395
 
441
396
class cmd_gpreferences(GTKCommand):
442
397
    """ GTK+ preferences dialog.
443
398
 
444
399
    """
445
400
    def run(self):
446
 
        open_display()
 
401
        self.open_display()
447
402
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
448
403
        dialog = PreferencesWindow()
449
404
        dialog.run()
450
405
 
451
406
 
 
407
 
452
408
class cmd_gmissing(Command):
453
409
    """ GTK+ missing revisions dialog.
454
410
 
487
443
 
488
444
class cmd_ginit(GTKCommand):
489
445
    def run(self):
490
 
        open_display()
 
446
        self.open_display()
491
447
        from initialize import InitDialog
492
448
        dialog = InitDialog(os.path.abspath(os.path.curdir))
493
449
        dialog.run()
497
453
    def run(self):
498
454
        br = branch.Branch.open_containing('.')[0]
499
455
        
500
 
        gtk = open_display()
 
456
        gtk = self.open_display()
501
457
        from tags import TagsWindow
502
458
        window = TagsWindow(br)
503
459
        window.show()
505
461
 
506
462
 
507
463
commands = [
 
464
    cmd_gmissing, 
 
465
    cmd_gpreferences, 
 
466
    cmd_gconflicts, 
 
467
    cmd_gstatus,
 
468
    cmd_gcommit, 
508
469
    cmd_gannotate, 
 
470
    cmd_visualise, 
 
471
    cmd_gdiff,
 
472
    cmd_gpush, 
 
473
    cmd_gcheckout, 
509
474
    cmd_gbranch,
510
 
    cmd_gcheckout, 
511
 
    cmd_gcommit, 
512
 
    cmd_gconflicts, 
513
 
    cmd_gdiff,
514
475
    cmd_ginit,
515
 
    cmd_gmissing, 
516
 
    cmd_gpreferences, 
517
 
    cmd_gpush, 
518
 
    cmd_gsend,
519
 
    cmd_gstatus,
520
 
    cmd_gtags,
521
 
    cmd_visualise
 
476
    cmd_gtags
522
477
    ]
523
478
 
524
479
for cmd in commands:
533
488
    """
534
489
 
535
490
    def run(self):
536
 
        from notify import NotifyPopupMenu
537
 
        gtk = open_display()
538
 
        menu = NotifyPopupMenu()
539
 
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
540
 
        icon.connect('popup-menu', menu.display)
541
 
 
 
491
        gtk = self.open_display()
542
492
        import cgi
543
493
        import dbus
544
494
        import dbus.service
549
499
        from bzrlib.transport import get_transport
550
500
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
551
501
            import dbus.glib
552
 
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
 
502
        from bzrlib.plugins.dbus import activity
553
503
        bus = dbus.SessionBus()
554
 
 
 
504
        # get the object so we can subscribe to callbacks from it.
 
505
        broadcast_service = bus.get_object(
 
506
            activity.Broadcast.DBUS_NAME,
 
507
            activity.Broadcast.DBUS_PATH)
555
508
        def catch_branch(revision_id, urls):
556
509
            # TODO: show all the urls, or perhaps choose the 'best'.
557
510
            url = urls[0]
580
533
                    from bzrlib.plugins.gtk.branch import BranchDialog
581
534
                    bd = BranchDialog(remote_path=url)
582
535
                    bd.run()
583
 
                nw.add_action("inspect", "Inspect", start_viz, None)
584
 
                nw.add_action("branch", "Branch", start_branch, None)
 
536
                nw.add_action("clicked", "Inspect", start_viz, None)
 
537
                nw.add_action("clicked", "Branch", start_branch, None)
585
538
                nw.set_timeout(5000)
586
539
                nw.show()
587
540
            except Exception, e:
588
541
                print e
589
542
                raise
590
 
        bus.add_signal_receiver(catch_branch,
591
 
                                dbus_interface=BROADCAST_INTERFACE,
592
 
                                signal_name="Revision")
 
543
        broadcast_service.connect_to_signal("Revision", catch_branch,
 
544
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
593
545
        pynotify.init("bzr commit-notify")
594
546
        gtk.main()
595
547
 
596
548
register_command(cmd_commit_notify)
597
549
 
598
550
 
599
 
class cmd_gselftest(GTKCommand):
600
 
    """Version of selftest that displays a notification at the end"""
601
 
 
602
 
    takes_args = builtins.cmd_selftest.takes_args
603
 
    takes_options = builtins.cmd_selftest.takes_options
604
 
    _see_also = ['selftest']
605
 
 
606
 
    def run(self, *args, **kwargs):
607
 
        import cgi
608
 
        import sys
609
 
        default_encoding = sys.getdefaultencoding()
610
 
        # prevent gtk from blowing up later
611
 
        gtk = import_pygtk()
612
 
        # prevent gtk from messing with default encoding
613
 
        import pynotify
614
 
        if sys.getdefaultencoding() != default_encoding:
615
 
            reload(sys)
616
 
            sys.setdefaultencoding(default_encoding)
617
 
        result = builtins.cmd_selftest().run(*args, **kwargs)
618
 
        if result == 0:
619
 
            summary = 'Success'
620
 
            body = 'Selftest succeeded in "%s"' % os.getcwd()
621
 
        if result == 1:
622
 
            summary = 'Failure'
623
 
            body = 'Selftest failed in "%s"' % os.getcwd()
624
 
        pynotify.init("bzr gselftest")
625
 
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
626
 
        note.set_timeout(pynotify.EXPIRES_NEVER)
627
 
        note.show()
628
 
 
629
 
 
630
 
register_command(cmd_gselftest)
631
 
 
632
 
 
633
 
class cmd_test_gtk(GTKCommand):
634
 
    """Version of selftest that just runs the gtk test suite."""
635
 
 
636
 
    takes_options = ['verbose',
637
 
                     Option('one', short_name='1',
638
 
                            help='Stop when one test fails.'),
639
 
                     Option('benchmark', help='Run the benchmarks.'),
640
 
                     Option('lsprof-timed',
641
 
                     help='Generate lsprof output for benchmarked'
642
 
                          ' sections of code.'),
643
 
                     Option('list-only',
644
 
                     help='List the tests instead of running them.'),
645
 
                     Option('randomize', type=str, argname="SEED",
646
 
                     help='Randomize the order of tests using the given'
647
 
                          ' seed or "now" for the current time.'),
648
 
                    ]
649
 
    takes_args = ['testspecs*']
650
 
 
651
 
    def run(self, verbose=None, one=False, benchmark=None,
652
 
            lsprof_timed=None, list_only=False, randomize=None,
653
 
            testspecs_list=None):
654
 
        from bzrlib import __path__ as bzrlib_path
655
 
        from bzrlib.tests import selftest
656
 
 
657
 
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
658
 
        if benchmark:
659
 
            print 'No benchmarks yet'
660
 
            return 3
661
 
 
662
 
            test_suite_factory = bench_suite
663
 
            if verbose is None:
664
 
                verbose = True
665
 
            # TODO: should possibly lock the history file...
666
 
            benchfile = open(".perf_history", "at", buffering=1)
667
 
        else:
668
 
            test_suite_factory = test_suite
669
 
            if verbose is None:
670
 
                verbose = False
671
 
            benchfile = None
672
 
 
673
 
        if testspecs_list is not None:
674
 
            pattern = '|'.join(testspecs_list)
675
 
        else:
676
 
            pattern = ".*"
677
 
 
678
 
        try:
679
 
            result = selftest(verbose=verbose,
680
 
                              pattern=pattern,
681
 
                              stop_on_failure=one,
682
 
                              test_suite_factory=test_suite_factory,
683
 
                              lsprof_timed=lsprof_timed,
684
 
                              bench_history=benchfile,
685
 
                              list_only=list_only,
686
 
                              random_seed=randomize,
687
 
                             )
688
 
        finally:
689
 
            if benchfile is not None:
690
 
                benchfile.close()
691
 
 
692
 
register_command(cmd_test_gtk)
693
 
 
694
 
 
695
 
 
696
551
import gettext
697
552
gettext.install('olive-gtk')
698
553
 
699
 
# Let's create a specialized alias to protect '_' from being erased by other
700
 
# uses of '_' as an anonymous variable (think pdb for one).
701
 
_i18n = gettext.gettext
702
554
 
703
555
class NoDisplayError(BzrCommandError):
704
556
    """gtk could not find a proper display"""
714
566
    default_encoding = sys.getdefaultencoding()
715
567
    try:
716
568
        result = TestSuite()
717
 
        try:
718
 
            import_pygtk()
719
 
        except errors.BzrCommandError:
720
 
            return result
721
569
        result.addTest(tests.test_suite())
722
570
    finally:
723
571
        if sys.getdefaultencoding() != default_encoding: