/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: Andrew Bennetts
  • Date: 2008-04-29 08:17:01 UTC
  • mto: This revision was merged to the branch mainline in revision 476.
  • Revision ID: andrew@puzzling.org-20080429081701-2pu9uteic8o88nre
Simple hack to fix gannotate.

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 
 
22
gcommit           GTK+ commit dialog.
23
23
gconflicts        GTK+ conflicts. 
24
24
gdiff             Show differences in working tree in a GTK+ Window. 
 
25
ghandle-patch     Display and optionally merge a merge directive or patch.
25
26
ginit             Initialise a new branch.
26
27
gmissing          GTK+ missing revisions dialog. 
27
28
gpreferences      GTK+ preferences dialog. 
28
 
gpush             GTK+ push. 
29
 
gstatus           GTK+ status dialog 
 
29
gpush             GTK+ push.
 
30
gsend             GTK+ send merge directive.
 
31
gstatus           GTK+ status dialog.
30
32
gtags             Manage branch tags.
31
33
visualise         Graphically visualise this branch. 
32
34
"""
33
35
 
 
36
import sys
 
37
 
34
38
import bzrlib
35
39
 
36
 
__version__ = '0.91.0'
37
 
version_info = tuple(int(n) for n in __version__.split('.'))
38
 
 
 
40
version_info = (0, 94, 0, 'dev', 0)
 
41
 
 
42
if version_info[3] == 'final':
 
43
    version_string = '%d.%d.%d' % version_info[:3]
 
44
else:
 
45
    version_string = '%d.%d.%d%s%d' % version_info
 
46
__version__ = version_string
 
47
 
 
48
required_bzrlib = (1, 3)
39
49
 
40
50
def check_bzrlib_version(desired):
41
51
    """Check that bzrlib is compatible.
42
52
 
43
53
    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
54
    """
48
 
    desired_plus = (desired[0], desired[1]+1)
49
55
    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
56
    try:
54
57
        from bzrlib.trace import warning
55
58
    except ImportError:
59
62
        from bzrlib.errors import BzrError
60
63
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
61
64
                ' %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])
 
65
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
 
66
 
 
67
 
 
68
if version_info[2] == "final":
 
69
    check_bzrlib_version(required_bzrlib)
70
70
 
71
71
from bzrlib.trace import warning
72
72
if __name__ != 'bzrlib.plugins.gtk':
78
78
    branch,
79
79
    builtins,
80
80
    errors,
 
81
    merge_directive,
81
82
    workingtree,
82
83
    )
83
84
""")
108
109
    return os.path.dirname(__file__)
109
110
 
110
111
 
 
112
def icon_path(*args):
 
113
    basedirs = [os.path.join(data_path()),
 
114
             "/usr/share/bzr-gtk", 
 
115
             "/usr/local/share/bzr-gtk"]
 
116
    for basedir in basedirs:
 
117
        path = os.path.join(basedir, 'icons', *args)
 
118
        if os.path.exists(path):
 
119
            return path
 
120
    return None
 
121
 
 
122
 
111
123
class GTKCommand(Command):
112
124
    """Abstract class providing GTK specific run commands."""
113
125
 
214
226
            wt.unlock()
215
227
 
216
228
 
217
 
def start_viz_window(branch, revision, limit=None):
 
229
def start_viz_window(branch, revisions, limit=None):
218
230
    """Start viz on branch with revision revision.
219
231
    
220
232
    :return: The viz window object.
221
233
    """
222
 
    from viz.branchwin import BranchWindow
223
 
    branch.lock_read()
224
 
    pp = BranchWindow()
225
 
    pp.set_branch(branch, revision, limit)
226
 
    # cleanup locks when the window is closed
227
 
    pp.connect("destroy", lambda w: branch.unlock())
228
 
    return pp
 
234
    from viz import BranchWindow
 
235
    return BranchWindow(branch, revisions, limit)
229
236
 
230
237
 
231
238
class cmd_visualise(Command):
241
248
        "revision",
242
249
        Option('limit', "Maximum number of revisions to display.",
243
250
               int, 'count')]
244
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
245
252
    aliases = [ "visualize", "vis", "viz" ]
246
253
 
247
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
248
255
        set_ui_factory()
249
 
        (br, path) = branch.Branch.open_containing(location)
250
 
        br.lock_read()
251
 
        try:
 
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)
252
261
            if revision is None:
253
 
                revid = br.last_revision()
254
 
                if revid is None:
255
 
                    return
 
262
                revids.append(br.last_revision())
256
263
            else:
257
264
                (revno, revid) = revision[0].in_history(br)
258
 
 
259
 
            import gtk
260
 
            pp = start_viz_window(br, revid, limit)
261
 
            pp.connect("destroy", lambda w: gtk.main_quit())
262
 
            pp.show()
263
 
            gtk.main()
264
 
        finally:
265
 
            br.unlock()
 
265
                revids.append(revid)
 
266
        import gtk
 
267
        pp = start_viz_window(br, revids, limit)
 
268
        pp.connect("destroy", lambda w: gtk.main_quit())
 
269
        pp.show()
 
270
        gtk.main()
266
271
 
267
272
 
268
273
class cmd_gannotate(GTKCommand):
312
317
        else:
313
318
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
314
319
 
315
 
        window = GAnnotateWindow(all, plain)
 
320
        window = GAnnotateWindow(all, plain, branch=br)
316
321
        window.connect("destroy", lambda w: gtk.main_quit())
317
 
        window.set_title(path + " - gannotate")
318
322
        config = GAnnotateConfig(window)
319
323
        window.show()
320
324
        br.lock_read()
335
339
    """GTK+ commit dialog
336
340
 
337
341
    Graphical user interface for committing revisions"""
338
 
    
 
342
 
339
343
    aliases = [ "gci" ]
340
344
    takes_args = []
341
345
    takes_options = []
354
358
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
355
359
            br = wt.branch
356
360
        except NoWorkingTree, e:
357
 
            path = e.base
358
 
            (br, path) = branch.Branch.open_containing(path)
359
 
 
360
 
        commit = CommitDialog(wt, path, not br)
361
 
        commit.run()
362
 
 
 
361
            from dialog import error_dialog
 
362
            error_dialog(_('Directory does not have a working tree'),
 
363
                         _('Operation aborted.'))
 
364
            return 1 # should this be retval=3?
 
365
 
 
366
        # It is a good habit to keep things locked for the duration, but it
 
367
        # could cause difficulties if someone wants to do things in another
 
368
        # window... We could lock_read() until we actually go to commit
 
369
        # changes... Just a thought.
 
370
        wt.lock_write()
 
371
        try:
 
372
            dlg = CommitDialog(wt)
 
373
            return dlg.run()
 
374
        finally:
 
375
            wt.unlock()
363
376
 
364
377
 
365
378
class cmd_gstatus(GTKCommand):
370
383
    
371
384
    aliases = [ "gst" ]
372
385
    takes_args = ['PATH?']
373
 
    takes_options = []
 
386
    takes_options = ['revision']
374
387
 
375
 
    def run(self, path='.'):
 
388
    def run(self, path='.', revision=None):
376
389
        import os
377
390
        gtk = self.open_display()
378
391
        from status import StatusDialog
379
392
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
380
 
        status = StatusDialog(wt, wt_path)
 
393
        
 
394
        if revision is not None:
 
395
            try:
 
396
                revision_id = revision[0].in_history(wt.branch).rev_id
 
397
            except:
 
398
                from bzrlib.errors import BzrError
 
399
                raise BzrError('Revision %r doesn\'t exist' % revision[0].user_spec )
 
400
        else:
 
401
            revision_id = None
 
402
 
 
403
        status = StatusDialog(wt, wt_path, revision_id)
381
404
        status.connect("destroy", gtk.main_quit)
382
405
        status.run()
383
406
 
384
407
 
 
408
class cmd_gsend(GTKCommand):
 
409
    """GTK+ send merge directive.
 
410
 
 
411
    """
 
412
    def run(self):
 
413
        (br, path) = branch.Branch.open_containing(".")
 
414
        gtk = self.open_display()
 
415
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
416
        from StringIO import StringIO
 
417
        dialog = SendMergeDirectiveDialog(br)
 
418
        if dialog.run() == gtk.RESPONSE_OK:
 
419
            outf = StringIO()
 
420
            outf.writelines(dialog.get_merge_directive().to_lines())
 
421
            mail_client = br.get_config().get_mail_client()
 
422
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
423
                outf.getvalue())
 
424
 
 
425
            
 
426
 
385
427
 
386
428
class cmd_gconflicts(GTKCommand):
387
 
    """ GTK+ conflicts.
 
429
    """GTK+ conflicts.
388
430
    
389
431
    Select files from the list of conflicts and run an external utility to
390
432
    resolve them.
397
439
        dialog.run()
398
440
 
399
441
 
400
 
 
401
442
class cmd_gpreferences(GTKCommand):
402
443
    """ GTK+ preferences dialog.
403
444
 
409
450
        dialog.run()
410
451
 
411
452
 
412
 
 
413
453
class cmd_gmissing(Command):
414
454
    """ GTK+ missing revisions dialog.
415
455
 
466
506
 
467
507
 
468
508
commands = [
 
509
    cmd_gannotate, 
 
510
    cmd_gbranch,
 
511
    cmd_gcheckout, 
 
512
    cmd_gcommit, 
 
513
    cmd_gconflicts, 
 
514
    cmd_gdiff,
 
515
    cmd_ginit,
469
516
    cmd_gmissing, 
470
517
    cmd_gpreferences, 
471
 
    cmd_gconflicts, 
 
518
    cmd_gpush, 
 
519
    cmd_gsend,
472
520
    cmd_gstatus,
473
 
    cmd_gcommit, 
474
 
    cmd_gannotate, 
475
 
    cmd_visualise, 
476
 
    cmd_gdiff,
477
 
    cmd_gpush, 
478
 
    cmd_gcheckout, 
479
 
    cmd_gbranch,
480
 
    cmd_ginit,
481
 
    cmd_gtags
 
521
    cmd_gtags,
 
522
    cmd_visualise
482
523
    ]
483
524
 
484
525
for cmd in commands:
496
537
        from notify import NotifyPopupMenu
497
538
        gtk = self.open_display()
498
539
        menu = NotifyPopupMenu()
499
 
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
 
540
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
500
541
        icon.connect('popup-menu', menu.display)
501
542
 
502
543
        import cgi
509
550
        from bzrlib.transport import get_transport
510
551
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
511
552
            import dbus.glib
512
 
        from bzrlib.plugins.dbus import activity
 
553
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
513
554
        bus = dbus.SessionBus()
514
 
        # get the object so we can subscribe to callbacks from it.
515
 
        broadcast_service = bus.get_object(
516
 
            activity.Broadcast.DBUS_NAME,
517
 
            activity.Broadcast.DBUS_PATH)
518
555
 
519
556
        def catch_branch(revision_id, urls):
520
557
            # TODO: show all the urls, or perhaps choose the 'best'.
551
588
            except Exception, e:
552
589
                print e
553
590
                raise
554
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
555
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
591
        bus.add_signal_receiver(catch_branch,
 
592
                                dbus_interface=BROADCAST_INTERFACE,
 
593
                                signal_name="Revision")
556
594
        pynotify.init("bzr commit-notify")
557
595
        gtk.main()
558
596
 
593
631
register_command(cmd_gselftest)
594
632
 
595
633
 
 
634
class cmd_test_gtk(GTKCommand):
 
635
    """Version of selftest that just runs the gtk test suite."""
 
636
 
 
637
    takes_options = ['verbose',
 
638
                     Option('one', short_name='1',
 
639
                            help='Stop when one test fails.'),
 
640
                     Option('benchmark', help='Run the benchmarks.'),
 
641
                     Option('lsprof-timed',
 
642
                     help='Generate lsprof output for benchmarked'
 
643
                          ' sections of code.'),
 
644
                     Option('list-only',
 
645
                     help='List the tests instead of running them.'),
 
646
                     Option('randomize', type=str, argname="SEED",
 
647
                     help='Randomize the order of tests using the given'
 
648
                          ' seed or "now" for the current time.'),
 
649
                    ]
 
650
    takes_args = ['testspecs*']
 
651
 
 
652
    def run(self, verbose=None, one=False, benchmark=None,
 
653
            lsprof_timed=None, list_only=False, randomize=None,
 
654
            testspecs_list=None):
 
655
        from bzrlib import __path__ as bzrlib_path
 
656
        from bzrlib.tests import selftest
 
657
 
 
658
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
659
        if benchmark:
 
660
            print 'No benchmarks yet'
 
661
            return 3
 
662
 
 
663
            test_suite_factory = bench_suite
 
664
            if verbose is None:
 
665
                verbose = True
 
666
            # TODO: should possibly lock the history file...
 
667
            benchfile = open(".perf_history", "at", buffering=1)
 
668
        else:
 
669
            test_suite_factory = test_suite
 
670
            if verbose is None:
 
671
                verbose = False
 
672
            benchfile = None
 
673
 
 
674
        if testspecs_list is not None:
 
675
            pattern = '|'.join(testspecs_list)
 
676
        else:
 
677
            pattern = ".*"
 
678
 
 
679
        try:
 
680
            result = selftest(verbose=verbose,
 
681
                              pattern=pattern,
 
682
                              stop_on_failure=one,
 
683
                              test_suite_factory=test_suite_factory,
 
684
                              lsprof_timed=lsprof_timed,
 
685
                              bench_history=benchfile,
 
686
                              list_only=list_only,
 
687
                              random_seed=randomize,
 
688
                             )
 
689
        finally:
 
690
            if benchfile is not None:
 
691
                benchfile.close()
 
692
 
 
693
register_command(cmd_test_gtk)
 
694
 
 
695
 
 
696
class cmd_ghandle_patch(GTKCommand):
 
697
    """Display a patch or merge directive, possibly merging.
 
698
 
 
699
    This is a helper, meant to be launched from other programs like browsers
 
700
    or email clients.  Since these programs often do not allow parameters to
 
701
    be provided, a "handle-patch" script is included.
 
702
    """
 
703
 
 
704
    takes_args = ['path']
 
705
 
 
706
    def run(self, path):
 
707
        try:
 
708
            from bzrlib.plugins.gtk.diff import (DiffWindow,
 
709
                                                 MergeDirectiveWindow)
 
710
            lines = open(path, 'rb').readlines()
 
711
            lines = [l.replace('\r\n', '\n') for l in lines]
 
712
            try:
 
713
                directive = merge_directive.MergeDirective.from_lines(lines)
 
714
            except errors.NotAMergeDirective:
 
715
                window = DiffWindow()
 
716
                window.set_diff_text(path, lines)
 
717
            else:
 
718
                window = MergeDirectiveWindow(directive, path)
 
719
                window.set_diff_text(path, directive.patch.splitlines(True))
 
720
            window.show()
 
721
            gtk = self.open_display()
 
722
            window.connect("destroy", gtk.main_quit)
 
723
        except Exception, e:
 
724
            from dialog import error_dialog
 
725
            error_dialog('Error', str(e))
 
726
            raise
 
727
        gtk.main()
 
728
 
 
729
 
 
730
register_command(cmd_ghandle_patch)
 
731
 
 
732
 
596
733
import gettext
597
734
gettext.install('olive-gtk')
598
735
 
611
748
    default_encoding = sys.getdefaultencoding()
612
749
    try:
613
750
        result = TestSuite()
 
751
        try:
 
752
            import_pygtk()
 
753
        except errors.BzrCommandError:
 
754
            return result
614
755
        result.addTest(tests.test_suite())
615
756
    finally:
616
757
        if sys.getdefaultencoding() != default_encoding: