/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-06-29 18:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629181229-1l2m4cf7vvbyh8qg
Simplify progress bar code, use embedded progress bar inside viz window.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
32
32
visualise         Graphically visualise this branch. 
33
33
"""
34
34
 
 
35
import sys
 
36
 
35
37
import bzrlib
36
38
 
37
 
version_info = (0, 92, 0, 'dev', 0)
 
39
version_info = (0, 95, 0, 'dev', 1)
38
40
 
39
41
if version_info[3] == 'final':
40
42
    version_string = '%d.%d.%d' % version_info[:3]
42
44
    version_string = '%d.%d.%d%s%d' % version_info
43
45
__version__ = version_string
44
46
 
 
47
required_bzrlib = (1, 3)
 
48
 
45
49
def check_bzrlib_version(desired):
46
50
    """Check that bzrlib is compatible.
47
51
 
48
52
    If version is < bzr-gtk version, assume incompatible.
49
 
    If version == bzr-gtk version, assume completely compatible
50
 
    If version == bzr-gtk version + 1, assume compatible, with deprecations
51
 
    Otherwise, assume incompatible.
52
53
    """
53
 
    desired_plus = (desired[0], desired[1]+1)
54
54
    bzrlib_version = bzrlib.version_info[:2]
55
 
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
56
 
                                     bzrlib.version_info[3] == 'dev'):
57
 
        return
58
55
    try:
59
56
        from bzrlib.trace import warning
60
57
    except ImportError:
65
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
66
63
                ' %s.' % (bzrlib.__version__, __version__))
67
64
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
68
 
    else:
69
 
        warning('bzr-gtk is not up to date with installed bzr version %s.'
70
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
71
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
72
65
 
73
66
 
74
67
if version_info[2] == "final":
75
 
    check_bzrlib_version(version_info[:2])
 
68
    check_bzrlib_version(required_bzrlib)
76
69
 
77
70
from bzrlib.trace import warning
78
71
if __name__ != 'bzrlib.plugins.gtk':
84
77
    branch,
85
78
    builtins,
86
79
    errors,
 
80
    merge_directive,
87
81
    workingtree,
88
82
    )
89
83
""")
114
108
    return os.path.dirname(__file__)
115
109
 
116
110
 
 
111
def icon_path(*args):
 
112
    basedirs = [os.path.join(data_path()),
 
113
             "/usr/share/bzr-gtk", 
 
114
             "/usr/local/share/bzr-gtk"]
 
115
    for basedir in basedirs:
 
116
        path = os.path.join(basedir, 'icons', *args)
 
117
        if os.path.exists(path):
 
118
            return path
 
119
    return None
 
120
 
 
121
 
 
122
def open_display():
 
123
    pygtk = import_pygtk()
 
124
    try:
 
125
        import gtk
 
126
    except RuntimeError, e:
 
127
        if str(e) == "could not open display":
 
128
            raise NoDisplayError
 
129
    set_ui_factory()
 
130
    return gtk
 
131
 
 
132
 
117
133
class GTKCommand(Command):
118
134
    """Abstract class providing GTK specific run commands."""
119
135
 
120
 
    def open_display(self):
121
 
        pygtk = import_pygtk()
122
 
        try:
123
 
            import gtk
124
 
        except RuntimeError, e:
125
 
            if str(e) == "could not open display":
126
 
                raise NoDisplayError
127
 
        set_ui_factory()
128
 
        return gtk
129
 
 
130
136
    def run(self):
131
 
        self.open_display()
 
137
        open_display()
132
138
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
133
139
        dialog.run()
134
140
 
162
168
 
163
169
    def run(self, location="."):
164
170
        (br, path) = branch.Branch.open_containing(location)
165
 
        self.open_display()
 
171
        open_display()
166
172
        from push import PushDialog
167
173
        dialog = PushDialog(br.repository, br.last_revision(), br)
168
174
        dialog.run()
187
193
            if revision is not None:
188
194
                if len(revision) == 1:
189
195
                    tree1 = wt
190
 
                    revision_id = revision[0].in_history(branch).rev_id
 
196
                    revision_id = revision[0].as_revision_id(tree1.branch)
191
197
                    tree2 = branch.repository.revision_tree(revision_id)
192
198
                elif len(revision) == 2:
193
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
199
                    revision_id_0 = revision[0].as_revision_id(branch)
194
200
                    tree2 = branch.repository.revision_tree(revision_id_0)
195
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
201
                    revision_id_1 = revision[1].as_revision_id(branch)
196
202
                    tree1 = branch.repository.revision_tree(revision_id_1)
197
203
            else:
198
204
                tree1 = wt
220
226
            wt.unlock()
221
227
 
222
228
 
223
 
def start_viz_window(branch, revision, limit=None):
 
229
def start_viz_window(branch, revisions, limit=None):
224
230
    """Start viz on branch with revision revision.
225
231
    
226
232
    :return: The viz window object.
227
233
    """
228
 
    from viz.branchwin import BranchWindow
229
 
    return BranchWindow(branch, revision, limit)
 
234
    from viz import BranchWindow
 
235
    return BranchWindow(branch, revisions, limit)
230
236
 
231
237
 
232
238
class cmd_visualise(Command):
242
248
        "revision",
243
249
        Option('limit', "Maximum number of revisions to display.",
244
250
               int, 'count')]
245
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
246
252
    aliases = [ "visualize", "vis", "viz" ]
247
253
 
248
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
249
255
        set_ui_factory()
250
 
        (br, path) = branch.Branch.open_containing(location)
251
 
        br.lock_read()
252
 
        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)
253
261
            if revision is None:
254
 
                revid = br.last_revision()
255
 
                if revid is None:
256
 
                    return
 
262
                revids.append(br.last_revision())
257
263
            else:
258
 
                (revno, revid) = revision[0].in_history(br)
259
 
 
260
 
            import gtk
261
 
            pp = start_viz_window(br, revid, limit)
262
 
            pp.connect("destroy", lambda w: gtk.main_quit())
263
 
            pp.show()
264
 
            gtk.main()
265
 
        finally:
266
 
            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()
267
270
 
268
271
 
269
272
class cmd_gannotate(GTKCommand):
283
286
    aliases = ["gblame", "gpraise"]
284
287
    
285
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
286
 
        gtk = self.open_display()
 
289
        gtk = open_display()
287
290
 
288
291
        try:
289
292
            line = int(line)
308
311
        if revision is not None:
309
312
            if len(revision) != 1:
310
313
                raise BzrCommandError("Only 1 revion may be specified.")
311
 
            revision_id = revision[0].in_history(br).rev_id
 
314
            revision_id = revision[0].as_revision_id(br)
312
315
            tree = br.repository.revision_tree(revision_id)
313
316
        else:
314
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
315
318
 
316
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
317
320
        window.connect("destroy", lambda w: gtk.main_quit())
318
 
        window.set_title(path + " - gannotate")
319
321
        config = GAnnotateConfig(window)
320
322
        window.show()
321
323
        br.lock_read()
336
338
    """GTK+ commit dialog
337
339
 
338
340
    Graphical user interface for committing revisions"""
339
 
    
 
341
 
340
342
    aliases = [ "gci" ]
341
343
    takes_args = []
342
344
    takes_options = []
343
345
 
344
346
    def run(self, filename=None):
345
347
        import os
346
 
        self.open_display()
 
348
        open_display()
347
349
        from commit import CommitDialog
348
350
        from bzrlib.errors import (BzrCommandError,
349
351
                                   NotBranchError,
355
357
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
356
358
            br = wt.branch
357
359
        except NoWorkingTree, e:
358
 
            path = e.base
359
 
            (br, path) = branch.Branch.open_containing(path)
360
 
 
361
 
        commit = CommitDialog(wt, path, not br)
362
 
        commit.run()
363
 
 
 
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()
364
375
 
365
376
 
366
377
class cmd_gstatus(GTKCommand):
371
382
    
372
383
    aliases = [ "gst" ]
373
384
    takes_args = ['PATH?']
374
 
    takes_options = []
 
385
    takes_options = ['revision']
375
386
 
376
 
    def run(self, path='.'):
 
387
    def run(self, path='.', revision=None):
377
388
        import os
378
 
        gtk = self.open_display()
 
389
        gtk = open_display()
379
390
        from status import StatusDialog
380
391
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
381
 
        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)
382
403
        status.connect("destroy", gtk.main_quit)
383
404
        status.run()
384
405
 
389
410
    """
390
411
    def run(self):
391
412
        (br, path) = branch.Branch.open_containing(".")
392
 
        gtk = self.open_display()
 
413
        gtk = open_display()
393
414
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
394
415
        from StringIO import StringIO
395
416
        dialog = SendMergeDirectiveDialog(br)
411
432
    """
412
433
    def run(self):
413
434
        (wt, path) = workingtree.WorkingTree.open_containing('.')
414
 
        self.open_display()
 
435
        open_display()
415
436
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
416
437
        dialog = ConflictsDialog(wt)
417
438
        dialog.run()
422
443
 
423
444
    """
424
445
    def run(self):
425
 
        self.open_display()
 
446
        open_display()
426
447
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
427
448
        dialog = PreferencesWindow()
428
449
        dialog.run()
466
487
 
467
488
class cmd_ginit(GTKCommand):
468
489
    def run(self):
469
 
        self.open_display()
 
490
        open_display()
470
491
        from initialize import InitDialog
471
492
        dialog = InitDialog(os.path.abspath(os.path.curdir))
472
493
        dialog.run()
476
497
    def run(self):
477
498
        br = branch.Branch.open_containing('.')[0]
478
499
        
479
 
        gtk = self.open_display()
 
500
        gtk = open_display()
480
501
        from tags import TagsWindow
481
502
        window = TagsWindow(br)
482
503
        window.show()
513
534
 
514
535
    def run(self):
515
536
        from notify import NotifyPopupMenu
516
 
        gtk = self.open_display()
 
537
        gtk = open_display()
517
538
        menu = NotifyPopupMenu()
518
 
        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"))
519
540
        icon.connect('popup-menu', menu.display)
520
541
 
521
542
        import cgi
528
549
        from bzrlib.transport import get_transport
529
550
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
530
551
            import dbus.glib
531
 
        from bzrlib.plugins.dbus import activity
 
552
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
532
553
        bus = dbus.SessionBus()
533
 
        # get the object so we can subscribe to callbacks from it.
534
 
        broadcast_service = bus.get_object(
535
 
            activity.Broadcast.DBUS_NAME,
536
 
            activity.Broadcast.DBUS_PATH)
537
554
 
538
555
        def catch_branch(revision_id, urls):
539
556
            # TODO: show all the urls, or perhaps choose the 'best'.
570
587
            except Exception, e:
571
588
                print e
572
589
                raise
573
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
574
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
590
        bus.add_signal_receiver(catch_branch,
 
591
                                dbus_interface=BROADCAST_INTERFACE,
 
592
                                signal_name="Revision")
575
593
        pynotify.init("bzr commit-notify")
576
594
        gtk.main()
577
595
 
612
630
register_command(cmd_gselftest)
613
631
 
614
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
 
615
696
import gettext
616
697
gettext.install('olive-gtk')
617
698
 
 
699
# Let's create a specialized alias to protect '_' from being erased by other
 
700
# uses of '_' as an anonymous variable (think pdb for one).
 
701
_i18n = gettext.gettext
618
702
 
619
703
class NoDisplayError(BzrCommandError):
620
704
    """gtk could not find a proper display"""
630
714
    default_encoding = sys.getdefaultencoding()
631
715
    try:
632
716
        result = TestSuite()
 
717
        try:
 
718
            import_pygtk()
 
719
        except errors.BzrCommandError:
 
720
            return result
633
721
        result.addTest(tests.test_suite())
634
722
    finally:
635
723
        if sys.getdefaultencoding() != default_encoding: