/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: 2008-03-09 13:47:52 UTC
  • mto: This revision was merged to the branch mainline in revision 447.
  • Revision ID: jelmer@samba.org-20080309134752-syf9kwzy6e919jhj
Add note about python-nautilus requiring a libpythonXX.so symlink.

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