/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: Szilveszter Farkas (Phanatic)
  • Date: 2008-03-03 17:24:22 UTC
  • mto: This revision was merged to the branch mainline in revision 435.
  • Revision ID: szilveszter.farkas@gmail.com-20080303172422-y1u0gg7kyirrxuun
Installing an olive package is pretty useless. (Fixed: #136432)

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, 0)
 
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
""")
224
220
    
225
221
    :return: The viz window object.
226
222
    """
227
 
    from viz.branchwin import BranchWindow
 
223
    from viz import BranchWindow
228
224
    return BranchWindow(branch, revision, limit)
229
225
 
230
226
 
247
243
    def run(self, location=".", revision=None, limit=None):
248
244
        set_ui_factory()
249
245
        (br, path) = branch.Branch.open_containing(location)
250
 
        br.lock_read()
251
 
        try:
252
 
            if revision is None:
253
 
                revid = br.last_revision()
254
 
                if revid is None:
255
 
                    return
256
 
            else:
257
 
                (revno, revid) = revision[0].in_history(br)
 
246
        if revision is None:
 
247
            revid = br.last_revision()
 
248
            if revid is None:
 
249
                return
 
250
        else:
 
251
            (revno, revid) = revision[0].in_history(br)
258
252
 
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()
 
253
        import gtk
 
254
        pp = start_viz_window(br, revid, limit)
 
255
        pp.connect("destroy", lambda w: gtk.main_quit())
 
256
        pp.show()
 
257
        gtk.main()
266
258
 
267
259
 
268
260
class cmd_gannotate(GTKCommand):
335
327
    """GTK+ commit dialog
336
328
 
337
329
    Graphical user interface for committing revisions"""
338
 
    
 
330
 
339
331
    aliases = [ "gci" ]
340
332
    takes_args = []
341
333
    takes_options = []
354
346
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
355
347
            br = wt.branch
356
348
        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
 
 
 
349
            from dialog import error_dialog
 
350
            error_dialog(_('Directory does not have a working tree'),
 
351
                         _('Operation aborted.'))
 
352
            return 1 # should this be retval=3?
 
353
 
 
354
        # It is a good habit to keep things locked for the duration, but it
 
355
        # could cause difficulties if someone wants to do things in another
 
356
        # window... We could lock_read() until we actually go to commit
 
357
        # changes... Just a thought.
 
358
        wt.lock_write()
 
359
        try:
 
360
            dlg = CommitDialog(wt)
 
361
            return dlg.run()
 
362
        finally:
 
363
            wt.unlock()
363
364
 
364
365
 
365
366
class cmd_gstatus(GTKCommand):
382
383
        status.run()
383
384
 
384
385
 
 
386
class cmd_gsend(GTKCommand):
 
387
    """GTK+ send merge directive.
 
388
 
 
389
    """
 
390
    def run(self):
 
391
        (br, path) = branch.Branch.open_containing(".")
 
392
        gtk = self.open_display()
 
393
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
394
        from StringIO import StringIO
 
395
        dialog = SendMergeDirectiveDialog(br)
 
396
        if dialog.run() == gtk.RESPONSE_OK:
 
397
            outf = StringIO()
 
398
            outf.writelines(dialog.get_merge_directive().to_lines())
 
399
            mail_client = br.get_config().get_mail_client()
 
400
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
401
                outf.getvalue())
 
402
 
 
403
            
 
404
 
385
405
 
386
406
class cmd_gconflicts(GTKCommand):
387
 
    """ GTK+ conflicts.
 
407
    """GTK+ conflicts.
388
408
    
389
409
    Select files from the list of conflicts and run an external utility to
390
410
    resolve them.
397
417
        dialog.run()
398
418
 
399
419
 
400
 
 
401
420
class cmd_gpreferences(GTKCommand):
402
421
    """ GTK+ preferences dialog.
403
422
 
409
428
        dialog.run()
410
429
 
411
430
 
412
 
 
413
431
class cmd_gmissing(Command):
414
432
    """ GTK+ missing revisions dialog.
415
433
 
466
484
 
467
485
 
468
486
commands = [
 
487
    cmd_gannotate, 
 
488
    cmd_gbranch,
 
489
    cmd_gcheckout, 
 
490
    cmd_gcommit, 
 
491
    cmd_gconflicts, 
 
492
    cmd_gdiff,
 
493
    cmd_ginit,
469
494
    cmd_gmissing, 
470
495
    cmd_gpreferences, 
471
 
    cmd_gconflicts, 
 
496
    cmd_gpush, 
 
497
    cmd_gsend,
472
498
    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
 
499
    cmd_gtags,
 
500
    cmd_visualise
482
501
    ]
483
502
 
484
503
for cmd in commands:
593
612
register_command(cmd_gselftest)
594
613
 
595
614
 
 
615
class cmd_test_gtk(GTKCommand):
 
616
    """Version of selftest that just runs the gtk test suite."""
 
617
 
 
618
    takes_options = ['verbose',
 
619
                     Option('one', short_name='1',
 
620
                            help='Stop when one test fails.'),
 
621
                     Option('benchmark', help='Run the benchmarks.'),
 
622
                     Option('lsprof-timed',
 
623
                     help='Generate lsprof output for benchmarked'
 
624
                          ' sections of code.'),
 
625
                     Option('list-only',
 
626
                     help='List the tests instead of running them.'),
 
627
                     Option('randomize', type=str, argname="SEED",
 
628
                     help='Randomize the order of tests using the given'
 
629
                          ' seed or "now" for the current time.'),
 
630
                    ]
 
631
    takes_args = ['testspecs*']
 
632
 
 
633
    def run(self, verbose=None, one=False, benchmark=None,
 
634
            lsprof_timed=None, list_only=False, randomize=None,
 
635
            testspecs_list=None):
 
636
        from bzrlib import __path__ as bzrlib_path
 
637
        from bzrlib.tests import selftest
 
638
 
 
639
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
640
        if benchmark:
 
641
            print 'No benchmarks yet'
 
642
            return 3
 
643
 
 
644
            test_suite_factory = bench_suite
 
645
            if verbose is None:
 
646
                verbose = True
 
647
            # TODO: should possibly lock the history file...
 
648
            benchfile = open(".perf_history", "at", buffering=1)
 
649
        else:
 
650
            test_suite_factory = test_suite
 
651
            if verbose is None:
 
652
                verbose = False
 
653
            benchfile = None
 
654
 
 
655
        if testspecs_list is not None:
 
656
            pattern = '|'.join(testspecs_list)
 
657
        else:
 
658
            pattern = ".*"
 
659
 
 
660
        try:
 
661
            result = selftest(verbose=verbose,
 
662
                              pattern=pattern,
 
663
                              stop_on_failure=one,
 
664
                              test_suite_factory=test_suite_factory,
 
665
                              lsprof_timed=lsprof_timed,
 
666
                              bench_history=benchfile,
 
667
                              list_only=list_only,
 
668
                              random_seed=randomize,
 
669
                             )
 
670
        finally:
 
671
            if benchfile is not None:
 
672
                benchfile.close()
 
673
 
 
674
register_command(cmd_test_gtk)
 
675
 
 
676
 
 
677
class cmd_ghandle_patch(GTKCommand):
 
678
    """Display a patch or merge directive, possibly merging.
 
679
 
 
680
    This is a helper, meant to be launched from other programs like browsers
 
681
    or email clients.  Since these programs often do not allow parameters to
 
682
    be provided, a "handle-patch" script is included.
 
683
    """
 
684
 
 
685
    takes_args = ['path']
 
686
 
 
687
    def run(self, path):
 
688
        from bzrlib.plugins.gtk.diff import DiffWindow, MergeDirectiveWindow
 
689
        lines = open(path, 'rb').readlines()
 
690
        try:
 
691
            directive = merge_directive.MergeDirective.from_lines(lines)
 
692
        except errors.NotAMergeDirective:
 
693
            window = DiffWindow()
 
694
            window.set_diff_text(path, lines)
 
695
        else:
 
696
            window = MergeDirectiveWindow(directive)
 
697
            window.set_diff_text(path, directive.patch.splitlines(True))
 
698
        window.show()
 
699
        gtk = self.open_display()
 
700
        window.connect("destroy", gtk.main_quit)
 
701
        gtk.main()
 
702
 
 
703
 
 
704
register_command(cmd_ghandle_patch)
 
705
 
 
706
 
596
707
import gettext
597
708
gettext.install('olive-gtk')
598
709
 
611
722
    default_encoding = sys.getdefaultencoding()
612
723
    try:
613
724
        result = TestSuite()
 
725
        try:
 
726
            import_pygtk()
 
727
        except errors.BzrCommandError:
 
728
            return result
614
729
        result.addTest(tests.test_suite())
615
730
    finally:
616
731
        if sys.getdefaultencoding() != default_encoding: