/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: Daniel Schierbeck
  • Date: 2008-04-07 20:34:51 UTC
  • mfrom: (450.6.13 bugs)
  • mto: (463.2.1 bug.78765)
  • mto: This revision was merged to the branch mainline in revision 462.
  • Revision ID: daniel.schierbeck@gmail.com-20080407203451-2i6el7jf9t0k9y64
Merged bug page improvements.

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_info = (0, 92, 0, 'dev', 0)
 
40
version_info = (0, 94, 0, 'dev', 0)
37
41
 
38
42
if version_info[3] == 'final':
39
43
    version_string = '%d.%d.%d' % version_info[:3]
41
45
    version_string = '%d.%d.%d%s%d' % version_info
42
46
__version__ = version_string
43
47
 
 
48
required_bzrlib = (1, 3)
 
49
 
44
50
def check_bzrlib_version(desired):
45
51
    """Check that bzrlib is compatible.
46
52
 
47
53
    If version is < bzr-gtk version, assume incompatible.
48
 
    If version == bzr-gtk version, assume completely compatible
49
 
    If version == bzr-gtk version + 1, assume compatible, with deprecations
50
 
    Otherwise, assume incompatible.
51
54
    """
52
 
    desired_plus = (desired[0], desired[1]+1)
53
55
    bzrlib_version = bzrlib.version_info[:2]
54
 
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
55
 
                                     bzrlib.version_info[3] == 'dev'):
56
 
        return
57
56
    try:
58
57
        from bzrlib.trace import warning
59
58
    except ImportError:
64
63
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
65
64
                ' %s.' % (bzrlib.__version__, __version__))
66
65
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
67
 
    else:
68
 
        warning('bzr-gtk is not up to date with installed bzr version %s.'
69
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
70
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
71
66
 
72
67
 
73
68
if version_info[2] == "final":
74
 
    check_bzrlib_version(version_info[:2])
 
69
    check_bzrlib_version(required_bzrlib)
75
70
 
76
71
from bzrlib.trace import warning
77
72
if __name__ != 'bzrlib.plugins.gtk':
83
78
    branch,
84
79
    builtins,
85
80
    errors,
 
81
    merge_directive,
86
82
    workingtree,
87
83
    )
88
84
""")
113
109
    return os.path.dirname(__file__)
114
110
 
115
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
 
116
123
class GTKCommand(Command):
117
124
    """Abstract class providing GTK specific run commands."""
118
125
 
219
226
            wt.unlock()
220
227
 
221
228
 
222
 
def start_viz_window(branch, revision, limit=None):
 
229
def start_viz_window(branch, revisions, limit=None):
223
230
    """Start viz on branch with revision revision.
224
231
    
225
232
    :return: The viz window object.
226
233
    """
227
 
    from viz.branchwin import BranchWindow
228
 
    return BranchWindow(branch, revision, limit)
 
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):
314
319
 
315
320
        window = GAnnotateWindow(all, plain)
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):
382
395
        status.run()
383
396
 
384
397
 
 
398
class cmd_gsend(GTKCommand):
 
399
    """GTK+ send merge directive.
 
400
 
 
401
    """
 
402
    def run(self):
 
403
        (br, path) = branch.Branch.open_containing(".")
 
404
        gtk = self.open_display()
 
405
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
406
        from StringIO import StringIO
 
407
        dialog = SendMergeDirectiveDialog(br)
 
408
        if dialog.run() == gtk.RESPONSE_OK:
 
409
            outf = StringIO()
 
410
            outf.writelines(dialog.get_merge_directive().to_lines())
 
411
            mail_client = br.get_config().get_mail_client()
 
412
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
413
                outf.getvalue())
 
414
 
 
415
            
 
416
 
385
417
 
386
418
class cmd_gconflicts(GTKCommand):
387
 
    """ GTK+ conflicts.
 
419
    """GTK+ conflicts.
388
420
    
389
421
    Select files from the list of conflicts and run an external utility to
390
422
    resolve them.
397
429
        dialog.run()
398
430
 
399
431
 
400
 
 
401
432
class cmd_gpreferences(GTKCommand):
402
433
    """ GTK+ preferences dialog.
403
434
 
409
440
        dialog.run()
410
441
 
411
442
 
412
 
 
413
443
class cmd_gmissing(Command):
414
444
    """ GTK+ missing revisions dialog.
415
445
 
466
496
 
467
497
 
468
498
commands = [
 
499
    cmd_gannotate, 
 
500
    cmd_gbranch,
 
501
    cmd_gcheckout, 
 
502
    cmd_gcommit, 
 
503
    cmd_gconflicts, 
 
504
    cmd_gdiff,
 
505
    cmd_ginit,
469
506
    cmd_gmissing, 
470
507
    cmd_gpreferences, 
471
 
    cmd_gconflicts, 
 
508
    cmd_gpush, 
 
509
    cmd_gsend,
472
510
    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
 
511
    cmd_gtags,
 
512
    cmd_visualise
482
513
    ]
483
514
 
484
515
for cmd in commands:
496
527
        from notify import NotifyPopupMenu
497
528
        gtk = self.open_display()
498
529
        menu = NotifyPopupMenu()
499
 
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
 
530
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
500
531
        icon.connect('popup-menu', menu.display)
501
532
 
502
533
        import cgi
509
540
        from bzrlib.transport import get_transport
510
541
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
511
542
            import dbus.glib
512
 
        from bzrlib.plugins.dbus import activity
 
543
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
513
544
        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
545
 
519
546
        def catch_branch(revision_id, urls):
520
547
            # TODO: show all the urls, or perhaps choose the 'best'.
551
578
            except Exception, e:
552
579
                print e
553
580
                raise
554
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
555
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
581
        bus.add_signal_receiver(catch_branch,
 
582
                                dbus_interface=BROADCAST_INTERFACE,
 
583
                                signal_name="Revision")
556
584
        pynotify.init("bzr commit-notify")
557
585
        gtk.main()
558
586
 
593
621
register_command(cmd_gselftest)
594
622
 
595
623
 
 
624
class cmd_test_gtk(GTKCommand):
 
625
    """Version of selftest that just runs the gtk test suite."""
 
626
 
 
627
    takes_options = ['verbose',
 
628
                     Option('one', short_name='1',
 
629
                            help='Stop when one test fails.'),
 
630
                     Option('benchmark', help='Run the benchmarks.'),
 
631
                     Option('lsprof-timed',
 
632
                     help='Generate lsprof output for benchmarked'
 
633
                          ' sections of code.'),
 
634
                     Option('list-only',
 
635
                     help='List the tests instead of running them.'),
 
636
                     Option('randomize', type=str, argname="SEED",
 
637
                     help='Randomize the order of tests using the given'
 
638
                          ' seed or "now" for the current time.'),
 
639
                    ]
 
640
    takes_args = ['testspecs*']
 
641
 
 
642
    def run(self, verbose=None, one=False, benchmark=None,
 
643
            lsprof_timed=None, list_only=False, randomize=None,
 
644
            testspecs_list=None):
 
645
        from bzrlib import __path__ as bzrlib_path
 
646
        from bzrlib.tests import selftest
 
647
 
 
648
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
649
        if benchmark:
 
650
            print 'No benchmarks yet'
 
651
            return 3
 
652
 
 
653
            test_suite_factory = bench_suite
 
654
            if verbose is None:
 
655
                verbose = True
 
656
            # TODO: should possibly lock the history file...
 
657
            benchfile = open(".perf_history", "at", buffering=1)
 
658
        else:
 
659
            test_suite_factory = test_suite
 
660
            if verbose is None:
 
661
                verbose = False
 
662
            benchfile = None
 
663
 
 
664
        if testspecs_list is not None:
 
665
            pattern = '|'.join(testspecs_list)
 
666
        else:
 
667
            pattern = ".*"
 
668
 
 
669
        try:
 
670
            result = selftest(verbose=verbose,
 
671
                              pattern=pattern,
 
672
                              stop_on_failure=one,
 
673
                              test_suite_factory=test_suite_factory,
 
674
                              lsprof_timed=lsprof_timed,
 
675
                              bench_history=benchfile,
 
676
                              list_only=list_only,
 
677
                              random_seed=randomize,
 
678
                             )
 
679
        finally:
 
680
            if benchfile is not None:
 
681
                benchfile.close()
 
682
 
 
683
register_command(cmd_test_gtk)
 
684
 
 
685
 
 
686
class cmd_ghandle_patch(GTKCommand):
 
687
    """Display a patch or merge directive, possibly merging.
 
688
 
 
689
    This is a helper, meant to be launched from other programs like browsers
 
690
    or email clients.  Since these programs often do not allow parameters to
 
691
    be provided, a "handle-patch" script is included.
 
692
    """
 
693
 
 
694
    takes_args = ['path']
 
695
 
 
696
    def run(self, path):
 
697
        try:
 
698
            from bzrlib.plugins.gtk.diff import (DiffWindow,
 
699
                                                 MergeDirectiveWindow)
 
700
            lines = open(path, 'rb').readlines()
 
701
            lines = [l.replace('\r\n', '\n') for l in lines]
 
702
            try:
 
703
                directive = merge_directive.MergeDirective.from_lines(lines)
 
704
            except errors.NotAMergeDirective:
 
705
                window = DiffWindow()
 
706
                window.set_diff_text(path, lines)
 
707
            else:
 
708
                window = MergeDirectiveWindow(directive, path)
 
709
                window.set_diff_text(path, directive.patch.splitlines(True))
 
710
            window.show()
 
711
            gtk = self.open_display()
 
712
            window.connect("destroy", gtk.main_quit)
 
713
        except Exception, e:
 
714
            from dialog import error_dialog
 
715
            error_dialog('Error', str(e))
 
716
            raise
 
717
        gtk.main()
 
718
 
 
719
 
 
720
register_command(cmd_ghandle_patch)
 
721
 
 
722
 
596
723
import gettext
597
724
gettext.install('olive-gtk')
598
725
 
611
738
    default_encoding = sys.getdefaultencoding()
612
739
    try:
613
740
        result = TestSuite()
 
741
        try:
 
742
            import_pygtk()
 
743
        except errors.BzrCommandError:
 
744
            return result
614
745
        result.addTest(tests.test_suite())
615
746
    finally:
616
747
        if sys.getdefaultencoding() != default_encoding: