/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: Martin Albisetti
  • Date: 2008-06-03 01:43:08 UTC
  • Revision ID: argentina@gmail.com-20080603014308-9e6ao0hsike02m2b
Add GTK;GNOME; to olive-gtk.desktop Categories

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, 95, 0, 'dev', 1)
 
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
 
181
193
            if revision is not None:
182
194
                if len(revision) == 1:
183
195
                    tree1 = wt
184
 
                    revision_id = revision[0].in_history(branch).rev_id
 
196
                    revision_id = revision[0].as_revision_id(tree1.branch)
185
197
                    tree2 = branch.repository.revision_tree(revision_id)
186
198
                elif len(revision) == 2:
187
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
199
                    revision_id_0 = revision[0].as_revision_id(branch)
188
200
                    tree2 = branch.repository.revision_tree(revision_id_0)
189
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
201
                    revision_id_1 = revision[1].as_revision_id(branch)
190
202
                    tree1 = branch.repository.revision_tree(revision_id_1)
191
203
            else:
192
204
                tree1 = wt
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
 
                (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()
 
264
                revids.append(revision[0].as_revision_id(br))
 
265
        import gtk
 
266
        pp = start_viz_window(br, revids, limit)
 
267
        pp.connect("destroy", lambda w: gtk.main_quit())
 
268
        pp.show()
 
269
        gtk.main()
266
270
 
267
271
 
268
272
class cmd_gannotate(GTKCommand):
307
311
        if revision is not None:
308
312
            if len(revision) != 1:
309
313
                raise BzrCommandError("Only 1 revion may be specified.")
310
 
            revision_id = revision[0].in_history(br).rev_id
 
314
            revision_id = revision[0].as_revision_id(br)
311
315
            tree = br.repository.revision_tree(revision_id)
312
316
        else:
313
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
314
318
 
315
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
316
320
        window.connect("destroy", lambda w: gtk.main_quit())
317
 
        window.set_title(path + " - gannotate")
318
321
        config = GAnnotateConfig(window)
319
322
        window.show()
320
323
        br.lock_read()
335
338
    """GTK+ commit dialog
336
339
 
337
340
    Graphical user interface for committing revisions"""
338
 
    
 
341
 
339
342
    aliases = [ "gci" ]
340
343
    takes_args = []
341
344
    takes_options = []
354
357
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
355
358
            br = wt.branch
356
359
        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
 
 
 
360
            from dialog import error_dialog
 
361
            error_dialog(_i18n('Directory does not have a working tree'),
 
362
                         _i18n('Operation aborted.'))
 
363
            return 1 # should this be retval=3?
 
364
 
 
365
        # It is a good habit to keep things locked for the duration, but it
 
366
        # could cause difficulties if someone wants to do things in another
 
367
        # window... We could lock_read() until we actually go to commit
 
368
        # changes... Just a thought.
 
369
        wt.lock_write()
 
370
        try:
 
371
            dlg = CommitDialog(wt)
 
372
            return dlg.run()
 
373
        finally:
 
374
            wt.unlock()
363
375
 
364
376
 
365
377
class cmd_gstatus(GTKCommand):
370
382
    
371
383
    aliases = [ "gst" ]
372
384
    takes_args = ['PATH?']
373
 
    takes_options = []
 
385
    takes_options = ['revision']
374
386
 
375
 
    def run(self, path='.'):
 
387
    def run(self, path='.', revision=None):
376
388
        import os
377
389
        gtk = self.open_display()
378
390
        from status import StatusDialog
379
391
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
380
 
        status = StatusDialog(wt, wt_path)
 
392
        
 
393
        if revision is not None:
 
394
            try:
 
395
                revision_id = revision[0].as_revision_id(wt.branch)
 
396
            except:
 
397
                from bzrlib.errors import BzrError
 
398
                raise BzrError('Revision %r doesn\'t exist' % revision[0].user_spec )
 
399
        else:
 
400
            revision_id = None
 
401
 
 
402
        status = StatusDialog(wt, wt_path, revision_id)
381
403
        status.connect("destroy", gtk.main_quit)
382
404
        status.run()
383
405
 
384
406
 
 
407
class cmd_gsend(GTKCommand):
 
408
    """GTK+ send merge directive.
 
409
 
 
410
    """
 
411
    def run(self):
 
412
        (br, path) = branch.Branch.open_containing(".")
 
413
        gtk = self.open_display()
 
414
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
415
        from StringIO import StringIO
 
416
        dialog = SendMergeDirectiveDialog(br)
 
417
        if dialog.run() == gtk.RESPONSE_OK:
 
418
            outf = StringIO()
 
419
            outf.writelines(dialog.get_merge_directive().to_lines())
 
420
            mail_client = br.get_config().get_mail_client()
 
421
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
422
                outf.getvalue())
 
423
 
 
424
            
 
425
 
385
426
 
386
427
class cmd_gconflicts(GTKCommand):
387
 
    """ GTK+ conflicts.
 
428
    """GTK+ conflicts.
388
429
    
389
430
    Select files from the list of conflicts and run an external utility to
390
431
    resolve them.
397
438
        dialog.run()
398
439
 
399
440
 
400
 
 
401
441
class cmd_gpreferences(GTKCommand):
402
442
    """ GTK+ preferences dialog.
403
443
 
409
449
        dialog.run()
410
450
 
411
451
 
412
 
 
413
452
class cmd_gmissing(Command):
414
453
    """ GTK+ missing revisions dialog.
415
454
 
466
505
 
467
506
 
468
507
commands = [
 
508
    cmd_gannotate, 
 
509
    cmd_gbranch,
 
510
    cmd_gcheckout, 
 
511
    cmd_gcommit, 
 
512
    cmd_gconflicts, 
 
513
    cmd_gdiff,
 
514
    cmd_ginit,
469
515
    cmd_gmissing, 
470
516
    cmd_gpreferences, 
471
 
    cmd_gconflicts, 
 
517
    cmd_gpush, 
 
518
    cmd_gsend,
472
519
    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
 
520
    cmd_gtags,
 
521
    cmd_visualise
482
522
    ]
483
523
 
484
524
for cmd in commands:
496
536
        from notify import NotifyPopupMenu
497
537
        gtk = self.open_display()
498
538
        menu = NotifyPopupMenu()
499
 
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
 
539
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
500
540
        icon.connect('popup-menu', menu.display)
501
541
 
502
542
        import cgi
509
549
        from bzrlib.transport import get_transport
510
550
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
511
551
            import dbus.glib
512
 
        from bzrlib.plugins.dbus import activity
 
552
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
513
553
        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
554
 
519
555
        def catch_branch(revision_id, urls):
520
556
            # TODO: show all the urls, or perhaps choose the 'best'.
551
587
            except Exception, e:
552
588
                print e
553
589
                raise
554
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
555
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
590
        bus.add_signal_receiver(catch_branch,
 
591
                                dbus_interface=BROADCAST_INTERFACE,
 
592
                                signal_name="Revision")
556
593
        pynotify.init("bzr commit-notify")
557
594
        gtk.main()
558
595
 
593
630
register_command(cmd_gselftest)
594
631
 
595
632
 
 
633
class cmd_test_gtk(GTKCommand):
 
634
    """Version of selftest that just runs the gtk test suite."""
 
635
 
 
636
    takes_options = ['verbose',
 
637
                     Option('one', short_name='1',
 
638
                            help='Stop when one test fails.'),
 
639
                     Option('benchmark', help='Run the benchmarks.'),
 
640
                     Option('lsprof-timed',
 
641
                     help='Generate lsprof output for benchmarked'
 
642
                          ' sections of code.'),
 
643
                     Option('list-only',
 
644
                     help='List the tests instead of running them.'),
 
645
                     Option('randomize', type=str, argname="SEED",
 
646
                     help='Randomize the order of tests using the given'
 
647
                          ' seed or "now" for the current time.'),
 
648
                    ]
 
649
    takes_args = ['testspecs*']
 
650
 
 
651
    def run(self, verbose=None, one=False, benchmark=None,
 
652
            lsprof_timed=None, list_only=False, randomize=None,
 
653
            testspecs_list=None):
 
654
        from bzrlib import __path__ as bzrlib_path
 
655
        from bzrlib.tests import selftest
 
656
 
 
657
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
658
        if benchmark:
 
659
            print 'No benchmarks yet'
 
660
            return 3
 
661
 
 
662
            test_suite_factory = bench_suite
 
663
            if verbose is None:
 
664
                verbose = True
 
665
            # TODO: should possibly lock the history file...
 
666
            benchfile = open(".perf_history", "at", buffering=1)
 
667
        else:
 
668
            test_suite_factory = test_suite
 
669
            if verbose is None:
 
670
                verbose = False
 
671
            benchfile = None
 
672
 
 
673
        if testspecs_list is not None:
 
674
            pattern = '|'.join(testspecs_list)
 
675
        else:
 
676
            pattern = ".*"
 
677
 
 
678
        try:
 
679
            result = selftest(verbose=verbose,
 
680
                              pattern=pattern,
 
681
                              stop_on_failure=one,
 
682
                              test_suite_factory=test_suite_factory,
 
683
                              lsprof_timed=lsprof_timed,
 
684
                              bench_history=benchfile,
 
685
                              list_only=list_only,
 
686
                              random_seed=randomize,
 
687
                             )
 
688
        finally:
 
689
            if benchfile is not None:
 
690
                benchfile.close()
 
691
 
 
692
register_command(cmd_test_gtk)
 
693
 
 
694
 
 
695
class cmd_ghandle_patch(GTKCommand):
 
696
    """Display a patch or merge directive, possibly merging.
 
697
 
 
698
    This is a helper, meant to be launched from other programs like browsers
 
699
    or email clients.  Since these programs often do not allow parameters to
 
700
    be provided, a "handle-patch" script is included.
 
701
    """
 
702
 
 
703
    takes_args = ['path']
 
704
 
 
705
    def run(self, path):
 
706
        try:
 
707
            from bzrlib.plugins.gtk.diff import (DiffController,
 
708
                                                 MergeDirectiveController)
 
709
            if path == '-':
 
710
                lines = sys.stdin.readlines()
 
711
            else:
 
712
                lines = open(path, 'rb').readlines()
 
713
            lines = [l.replace('\r\n', '\n') for l in lines]
 
714
            try:
 
715
                directive = merge_directive.MergeDirective.from_lines(lines)
 
716
            except errors.NotAMergeDirective:
 
717
                controller = DiffController(path, lines)
 
718
            else:
 
719
                controller = MergeDirectiveController(path, directive)
 
720
            window = controller.window
 
721
            window.show()
 
722
            gtk = self.open_display()
 
723
            window.connect("destroy", gtk.main_quit)
 
724
        except Exception, e:
 
725
            from dialog import error_dialog
 
726
            error_dialog('Error', str(e))
 
727
            raise
 
728
        gtk.main()
 
729
 
 
730
 
 
731
register_command(cmd_ghandle_patch)
 
732
 
 
733
 
596
734
import gettext
597
735
gettext.install('olive-gtk')
598
736
 
 
737
# Let's create a specialized alias to protect '_' from being erased by other
 
738
# uses of '_' as an anonymous variable (think pdb for one).
 
739
_i18n = gettext.gettext
599
740
 
600
741
class NoDisplayError(BzrCommandError):
601
742
    """gtk could not find a proper display"""
611
752
    default_encoding = sys.getdefaultencoding()
612
753
    try:
613
754
        result = TestSuite()
 
755
        try:
 
756
            import_pygtk()
 
757
        except errors.BzrCommandError:
 
758
            return result
614
759
        result.addTest(tests.test_suite())
615
760
    finally:
616
761
        if sys.getdefaultencoding() != default_encoding: