/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
36
36
 
37
37
import bzrlib
38
38
 
39
 
version_info = (0, 93, 0, 'dev', 0)
 
39
version_info = (0, 95, 0, 'dev', 1)
40
40
 
41
41
if version_info[3] == 'final':
42
42
    version_string = '%d.%d.%d' % version_info[:3]
44
44
    version_string = '%d.%d.%d%s%d' % version_info
45
45
__version__ = version_string
46
46
 
 
47
required_bzrlib = (1, 3)
 
48
 
47
49
def check_bzrlib_version(desired):
48
50
    """Check that bzrlib is compatible.
49
51
 
50
52
    If version is < bzr-gtk version, assume incompatible.
51
 
    If version == bzr-gtk version, assume completely compatible
52
 
    If version == bzr-gtk version + 1, assume compatible, with deprecations
53
 
    Otherwise, assume incompatible.
54
53
    """
55
 
    desired_plus = (desired[0], desired[1]+1)
56
54
    bzrlib_version = bzrlib.version_info[:2]
57
 
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
58
 
                                     bzrlib.version_info[3] == 'dev'):
59
 
        return
60
55
    try:
61
56
        from bzrlib.trace import warning
62
57
    except ImportError:
67
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
68
63
                ' %s.' % (bzrlib.__version__, __version__))
69
64
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
70
 
    else:
71
 
        warning('bzr-gtk is not up to date with installed bzr version %s.'
72
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
73
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
74
65
 
75
66
 
76
67
if version_info[2] == "final":
77
 
    check_bzrlib_version(version_info[:2])
 
68
    check_bzrlib_version(required_bzrlib)
78
69
 
79
70
from bzrlib.trace import warning
80
71
if __name__ != 'bzrlib.plugins.gtk':
86
77
    branch,
87
78
    builtins,
88
79
    errors,
 
80
    merge_directive,
89
81
    workingtree,
90
82
    )
91
83
""")
116
108
    return os.path.dirname(__file__)
117
109
 
118
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
 
119
133
class GTKCommand(Command):
120
134
    """Abstract class providing GTK specific run commands."""
121
135
 
122
 
    def open_display(self):
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
136
    def run(self):
133
 
        self.open_display()
 
137
        open_display()
134
138
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
135
139
        dialog.run()
136
140
 
164
168
 
165
169
    def run(self, location="."):
166
170
        (br, path) = branch.Branch.open_containing(location)
167
 
        self.open_display()
 
171
        open_display()
168
172
        from push import PushDialog
169
173
        dialog = PushDialog(br.repository, br.last_revision(), br)
170
174
        dialog.run()
189
193
            if revision is not None:
190
194
                if len(revision) == 1:
191
195
                    tree1 = wt
192
 
                    revision_id = revision[0].in_history(branch).rev_id
 
196
                    revision_id = revision[0].as_revision_id(tree1.branch)
193
197
                    tree2 = branch.repository.revision_tree(revision_id)
194
198
                elif len(revision) == 2:
195
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
199
                    revision_id_0 = revision[0].as_revision_id(branch)
196
200
                    tree2 = branch.repository.revision_tree(revision_id_0)
197
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
201
                    revision_id_1 = revision[1].as_revision_id(branch)
198
202
                    tree1 = branch.repository.revision_tree(revision_id_1)
199
203
            else:
200
204
                tree1 = wt
222
226
            wt.unlock()
223
227
 
224
228
 
225
 
def start_viz_window(branch, revision, limit=None):
 
229
def start_viz_window(branch, revisions, limit=None):
226
230
    """Start viz on branch with revision revision.
227
231
    
228
232
    :return: The viz window object.
229
233
    """
230
 
    from viz.branchwin import BranchWindow
231
 
    return BranchWindow(branch, revision, limit)
 
234
    from viz import BranchWindow
 
235
    return BranchWindow(branch, revisions, limit)
232
236
 
233
237
 
234
238
class cmd_visualise(Command):
244
248
        "revision",
245
249
        Option('limit', "Maximum number of revisions to display.",
246
250
               int, 'count')]
247
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
248
252
    aliases = [ "visualize", "vis", "viz" ]
249
253
 
250
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
251
255
        set_ui_factory()
252
 
        (br, path) = branch.Branch.open_containing(location)
253
 
        if revision is None:
254
 
            revid = br.last_revision()
255
 
            if revid is None:
256
 
                return
257
 
        else:
258
 
            (revno, revid) = revision[0].in_history(br)
259
 
 
 
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)
 
261
            if revision is None:
 
262
                revids.append(br.last_revision())
 
263
            else:
 
264
                revids.append(revision[0].as_revision_id(br))
260
265
        import gtk
261
 
        pp = start_viz_window(br, revid, limit)
 
266
        pp = start_viz_window(br, revids, limit)
262
267
        pp.connect("destroy", lambda w: gtk.main_quit())
263
268
        pp.show()
264
269
        gtk.main()
281
286
    aliases = ["gblame", "gpraise"]
282
287
    
283
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
284
 
        gtk = self.open_display()
 
289
        gtk = open_display()
285
290
 
286
291
        try:
287
292
            line = int(line)
306
311
        if revision is not None:
307
312
            if len(revision) != 1:
308
313
                raise BzrCommandError("Only 1 revion may be specified.")
309
 
            revision_id = revision[0].in_history(br).rev_id
 
314
            revision_id = revision[0].as_revision_id(br)
310
315
            tree = br.repository.revision_tree(revision_id)
311
316
        else:
312
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
313
318
 
314
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
315
320
        window.connect("destroy", lambda w: gtk.main_quit())
316
 
        window.set_title(path + " - gannotate")
317
321
        config = GAnnotateConfig(window)
318
322
        window.show()
319
323
        br.lock_read()
341
345
 
342
346
    def run(self, filename=None):
343
347
        import os
344
 
        self.open_display()
 
348
        open_display()
345
349
        from commit import CommitDialog
346
350
        from bzrlib.errors import (BzrCommandError,
347
351
                                   NotBranchError,
354
358
            br = wt.branch
355
359
        except NoWorkingTree, e:
356
360
            from dialog import error_dialog
357
 
            error_dialog(_('Directory does not have a working tree'),
358
 
                         _('Operation aborted.'))
 
361
            error_dialog(_i18n('Directory does not have a working tree'),
 
362
                         _i18n('Operation aborted.'))
359
363
            return 1 # should this be retval=3?
360
364
 
361
365
        # It is a good habit to keep things locked for the duration, but it
378
382
    
379
383
    aliases = [ "gst" ]
380
384
    takes_args = ['PATH?']
381
 
    takes_options = []
 
385
    takes_options = ['revision']
382
386
 
383
 
    def run(self, path='.'):
 
387
    def run(self, path='.', revision=None):
384
388
        import os
385
 
        gtk = self.open_display()
 
389
        gtk = open_display()
386
390
        from status import StatusDialog
387
391
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
388
 
        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)
389
403
        status.connect("destroy", gtk.main_quit)
390
404
        status.run()
391
405
 
396
410
    """
397
411
    def run(self):
398
412
        (br, path) = branch.Branch.open_containing(".")
399
 
        gtk = self.open_display()
 
413
        gtk = open_display()
400
414
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
401
415
        from StringIO import StringIO
402
416
        dialog = SendMergeDirectiveDialog(br)
418
432
    """
419
433
    def run(self):
420
434
        (wt, path) = workingtree.WorkingTree.open_containing('.')
421
 
        self.open_display()
 
435
        open_display()
422
436
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
423
437
        dialog = ConflictsDialog(wt)
424
438
        dialog.run()
429
443
 
430
444
    """
431
445
    def run(self):
432
 
        self.open_display()
 
446
        open_display()
433
447
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
434
448
        dialog = PreferencesWindow()
435
449
        dialog.run()
473
487
 
474
488
class cmd_ginit(GTKCommand):
475
489
    def run(self):
476
 
        self.open_display()
 
490
        open_display()
477
491
        from initialize import InitDialog
478
492
        dialog = InitDialog(os.path.abspath(os.path.curdir))
479
493
        dialog.run()
483
497
    def run(self):
484
498
        br = branch.Branch.open_containing('.')[0]
485
499
        
486
 
        gtk = self.open_display()
 
500
        gtk = open_display()
487
501
        from tags import TagsWindow
488
502
        window = TagsWindow(br)
489
503
        window.show()
520
534
 
521
535
    def run(self):
522
536
        from notify import NotifyPopupMenu
523
 
        gtk = self.open_display()
 
537
        gtk = open_display()
524
538
        menu = NotifyPopupMenu()
525
 
        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"))
526
540
        icon.connect('popup-menu', menu.display)
527
541
 
528
542
        import cgi
535
549
        from bzrlib.transport import get_transport
536
550
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
537
551
            import dbus.glib
538
 
        from bzrlib.plugins.dbus import activity
 
552
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
539
553
        bus = dbus.SessionBus()
540
 
        # get the object so we can subscribe to callbacks from it.
541
 
        broadcast_service = bus.get_object(
542
 
            activity.Broadcast.DBUS_NAME,
543
 
            activity.Broadcast.DBUS_PATH)
544
554
 
545
555
        def catch_branch(revision_id, urls):
546
556
            # TODO: show all the urls, or perhaps choose the 'best'.
577
587
            except Exception, e:
578
588
                print e
579
589
                raise
580
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
581
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
590
        bus.add_signal_receiver(catch_branch,
 
591
                                dbus_interface=BROADCAST_INTERFACE,
 
592
                                signal_name="Revision")
582
593
        pynotify.init("bzr commit-notify")
583
594
        gtk.main()
584
595
 
624
635
 
625
636
    takes_options = ['verbose',
626
637
                     Option('one', short_name='1',
627
 
                            help='stop when one test fails'),
628
 
                     Option('benchmark', help='run the benchmarks.'),
 
638
                            help='Stop when one test fails.'),
 
639
                     Option('benchmark', help='Run the benchmarks.'),
629
640
                     Option('lsprof-timed',
630
 
                     help='generate lsprof output for benchmarked'
 
641
                     help='Generate lsprof output for benchmarked'
631
642
                          ' sections of code.'),
632
643
                     Option('list-only',
633
 
                     help='list the tests instead of running them'),
 
644
                     help='List the tests instead of running them.'),
634
645
                     Option('randomize', type=str, argname="SEED",
635
 
                     help='randomize the order of tests using the given'
636
 
                          ' seed or "now" for the current time'),
 
646
                     help='Randomize the order of tests using the given'
 
647
                          ' seed or "now" for the current time.'),
637
648
                    ]
638
649
    takes_args = ['testspecs*']
639
650
 
681
692
register_command(cmd_test_gtk)
682
693
 
683
694
 
 
695
 
684
696
import gettext
685
697
gettext.install('olive-gtk')
686
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
687
702
 
688
703
class NoDisplayError(BzrCommandError):
689
704
    """gtk could not find a proper display"""
699
714
    default_encoding = sys.getdefaultencoding()
700
715
    try:
701
716
        result = TestSuite()
 
717
        try:
 
718
            import_pygtk()
 
719
        except errors.BzrCommandError:
 
720
            return result
702
721
        result.addTest(tests.test_suite())
703
722
    finally:
704
723
        if sys.getdefaultencoding() != default_encoding: