/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 
23
 
gconflicts        GTK+ push. 
 
22
gcommit           GTK+ commit dialog.
 
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.19.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:
57
60
        from warnings import warn as warning
58
61
    if bzrlib_version < desired:
59
62
        from bzrlib.errors import BzrError
60
 
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
 
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]) REMOVE
 
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':
76
76
lazy_import(globals(), """
77
77
from bzrlib import (
78
78
    branch,
 
79
    builtins,
79
80
    errors,
 
81
    merge_directive,
80
82
    workingtree,
81
83
    )
82
84
""")
103
105
    bzrlib.ui.ui_factory = GtkUIFactory()
104
106
 
105
107
 
 
108
def data_path():
 
109
    return os.path.dirname(__file__)
 
110
 
 
111
 
106
112
class GTKCommand(Command):
107
113
    """Abstract class providing GTK specific run commands."""
108
114
 
214
220
    
215
221
    :return: The viz window object.
216
222
    """
217
 
    from viz.branchwin import BranchWindow
218
 
    branch.lock_read()
219
 
    pp = BranchWindow()
220
 
    pp.set_branch(branch, revision, limit)
221
 
    # cleanup locks when the window is closed
222
 
    pp.connect("destroy", lambda w: branch.unlock())
223
 
    return pp
 
223
    from viz import BranchWindow
 
224
    return BranchWindow(branch, revision, limit)
224
225
 
225
226
 
226
227
class cmd_visualise(Command):
242
243
    def run(self, location=".", revision=None, limit=None):
243
244
        set_ui_factory()
244
245
        (br, path) = branch.Branch.open_containing(location)
245
 
        br.lock_read()
246
 
        try:
247
 
            if revision is None:
248
 
                revid = br.last_revision()
249
 
                if revid is None:
250
 
                    return
251
 
            else:
252
 
                (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)
253
252
 
254
 
            import gtk
255
 
            pp = start_viz_window(br, revid, limit)
256
 
            pp.connect("destroy", lambda w: gtk.main_quit())
257
 
            pp.show()
258
 
            gtk.main()
259
 
        finally:
260
 
            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()
261
258
 
262
259
 
263
260
class cmd_gannotate(GTKCommand):
330
327
    """GTK+ commit dialog
331
328
 
332
329
    Graphical user interface for committing revisions"""
333
 
    
 
330
 
334
331
    aliases = [ "gci" ]
335
332
    takes_args = []
336
333
    takes_options = []
349
346
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
350
347
            br = wt.branch
351
348
        except NoWorkingTree, e:
352
 
            path = e.base
353
 
            (br, path) = branch.Branch.open_containing(path)
354
 
 
355
 
        commit = CommitDialog(wt, path, not br)
356
 
        commit.run()
357
 
 
 
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()
358
364
 
359
365
 
360
366
class cmd_gstatus(GTKCommand):
377
383
        status.run()
378
384
 
379
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
 
380
405
 
381
406
class cmd_gconflicts(GTKCommand):
382
 
    """ GTK+ push.
 
407
    """GTK+ conflicts.
383
408
    
 
409
    Select files from the list of conflicts and run an external utility to
 
410
    resolve them.
384
411
    """
385
412
    def run(self):
386
413
        (wt, path) = workingtree.WorkingTree.open_containing('.')
390
417
        dialog.run()
391
418
 
392
419
 
393
 
 
394
420
class cmd_gpreferences(GTKCommand):
395
421
    """ GTK+ preferences dialog.
396
422
 
402
428
        dialog.run()
403
429
 
404
430
 
405
 
 
406
431
class cmd_gmissing(Command):
407
432
    """ GTK+ missing revisions dialog.
408
433
 
459
484
 
460
485
 
461
486
commands = [
 
487
    cmd_gannotate, 
 
488
    cmd_gbranch,
 
489
    cmd_gcheckout, 
 
490
    cmd_gcommit, 
 
491
    cmd_gconflicts, 
 
492
    cmd_gdiff,
 
493
    cmd_ginit,
462
494
    cmd_gmissing, 
463
495
    cmd_gpreferences, 
464
 
    cmd_gconflicts, 
 
496
    cmd_gpush, 
 
497
    cmd_gsend,
465
498
    cmd_gstatus,
466
 
    cmd_gcommit, 
467
 
    cmd_gannotate, 
468
 
    cmd_visualise, 
469
 
    cmd_gdiff,
470
 
    cmd_gpush, 
471
 
    cmd_gcheckout, 
472
 
    cmd_gbranch,
473
 
    cmd_ginit,
474
 
    cmd_gtags
 
499
    cmd_gtags,
 
500
    cmd_visualise
475
501
    ]
476
502
 
477
503
for cmd in commands:
489
515
        from notify import NotifyPopupMenu
490
516
        gtk = self.open_display()
491
517
        menu = NotifyPopupMenu()
492
 
        icon = gtk.status_icon_new_from_file("bzr-icon-64.png")
 
518
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
493
519
        icon.connect('popup-menu', menu.display)
494
520
 
495
521
        import cgi
552
578
register_command(cmd_commit_notify)
553
579
 
554
580
 
 
581
class cmd_gselftest(GTKCommand):
 
582
    """Version of selftest that displays a notification at the end"""
 
583
 
 
584
    takes_args = builtins.cmd_selftest.takes_args
 
585
    takes_options = builtins.cmd_selftest.takes_options
 
586
    _see_also = ['selftest']
 
587
 
 
588
    def run(self, *args, **kwargs):
 
589
        import cgi
 
590
        import sys
 
591
        default_encoding = sys.getdefaultencoding()
 
592
        # prevent gtk from blowing up later
 
593
        gtk = import_pygtk()
 
594
        # prevent gtk from messing with default encoding
 
595
        import pynotify
 
596
        if sys.getdefaultencoding() != default_encoding:
 
597
            reload(sys)
 
598
            sys.setdefaultencoding(default_encoding)
 
599
        result = builtins.cmd_selftest().run(*args, **kwargs)
 
600
        if result == 0:
 
601
            summary = 'Success'
 
602
            body = 'Selftest succeeded in "%s"' % os.getcwd()
 
603
        if result == 1:
 
604
            summary = 'Failure'
 
605
            body = 'Selftest failed in "%s"' % os.getcwd()
 
606
        pynotify.init("bzr gselftest")
 
607
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
 
608
        note.set_timeout(pynotify.EXPIRES_NEVER)
 
609
        note.show()
 
610
 
 
611
 
 
612
register_command(cmd_gselftest)
 
613
 
 
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
 
555
707
import gettext
556
708
gettext.install('olive-gtk')
557
709
 
570
722
    default_encoding = sys.getdefaultencoding()
571
723
    try:
572
724
        result = TestSuite()
 
725
        try:
 
726
            import_pygtk()
 
727
        except errors.BzrCommandError:
 
728
            return result
573
729
        result.addTest(tests.test_suite())
574
730
    finally:
575
731
        if sys.getdefaultencoding() != default_encoding: