/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 15:47:30 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629154730-xfsotoxwkiytf0ph
Pass graph object rather than full repository to linegraph.

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, 92, 0, 'final', 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
 
        br.lock_read()
254
 
        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)
255
261
            if revision is None:
256
 
                revid = br.last_revision()
257
 
                if revid is None:
258
 
                    return
 
262
                revids.append(br.last_revision())
259
263
            else:
260
 
                (revno, revid) = revision[0].in_history(br)
261
 
 
262
 
            import gtk
263
 
            pp = start_viz_window(br, revid, limit)
264
 
            pp.connect("destroy", lambda w: gtk.main_quit())
265
 
            pp.show()
266
 
            gtk.main()
267
 
        finally:
268
 
            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()
269
270
 
270
271
 
271
272
class cmd_gannotate(GTKCommand):
285
286
    aliases = ["gblame", "gpraise"]
286
287
    
287
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
288
 
        gtk = self.open_display()
 
289
        gtk = open_display()
289
290
 
290
291
        try:
291
292
            line = int(line)
310
311
        if revision is not None:
311
312
            if len(revision) != 1:
312
313
                raise BzrCommandError("Only 1 revion may be specified.")
313
 
            revision_id = revision[0].in_history(br).rev_id
 
314
            revision_id = revision[0].as_revision_id(br)
314
315
            tree = br.repository.revision_tree(revision_id)
315
316
        else:
316
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
317
318
 
318
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
319
320
        window.connect("destroy", lambda w: gtk.main_quit())
320
 
        window.set_title(path + " - gannotate")
321
321
        config = GAnnotateConfig(window)
322
322
        window.show()
323
323
        br.lock_read()
345
345
 
346
346
    def run(self, filename=None):
347
347
        import os
348
 
        self.open_display()
 
348
        open_display()
349
349
        from commit import CommitDialog
350
350
        from bzrlib.errors import (BzrCommandError,
351
351
                                   NotBranchError,
358
358
            br = wt.branch
359
359
        except NoWorkingTree, e:
360
360
            from dialog import error_dialog
361
 
            error_dialog(_('Directory does not have a working tree'),
362
 
                         _('Operation aborted.'))
 
361
            error_dialog(_i18n('Directory does not have a working tree'),
 
362
                         _i18n('Operation aborted.'))
363
363
            return 1 # should this be retval=3?
364
364
 
365
365
        # It is a good habit to keep things locked for the duration, but it
382
382
    
383
383
    aliases = [ "gst" ]
384
384
    takes_args = ['PATH?']
385
 
    takes_options = []
 
385
    takes_options = ['revision']
386
386
 
387
 
    def run(self, path='.'):
 
387
    def run(self, path='.', revision=None):
388
388
        import os
389
 
        gtk = self.open_display()
 
389
        gtk = open_display()
390
390
        from status import StatusDialog
391
391
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
392
 
        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)
393
403
        status.connect("destroy", gtk.main_quit)
394
404
        status.run()
395
405
 
400
410
    """
401
411
    def run(self):
402
412
        (br, path) = branch.Branch.open_containing(".")
403
 
        gtk = self.open_display()
 
413
        gtk = open_display()
404
414
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
405
415
        from StringIO import StringIO
406
416
        dialog = SendMergeDirectiveDialog(br)
422
432
    """
423
433
    def run(self):
424
434
        (wt, path) = workingtree.WorkingTree.open_containing('.')
425
 
        self.open_display()
 
435
        open_display()
426
436
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
427
437
        dialog = ConflictsDialog(wt)
428
438
        dialog.run()
433
443
 
434
444
    """
435
445
    def run(self):
436
 
        self.open_display()
 
446
        open_display()
437
447
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
438
448
        dialog = PreferencesWindow()
439
449
        dialog.run()
477
487
 
478
488
class cmd_ginit(GTKCommand):
479
489
    def run(self):
480
 
        self.open_display()
 
490
        open_display()
481
491
        from initialize import InitDialog
482
492
        dialog = InitDialog(os.path.abspath(os.path.curdir))
483
493
        dialog.run()
487
497
    def run(self):
488
498
        br = branch.Branch.open_containing('.')[0]
489
499
        
490
 
        gtk = self.open_display()
 
500
        gtk = open_display()
491
501
        from tags import TagsWindow
492
502
        window = TagsWindow(br)
493
503
        window.show()
524
534
 
525
535
    def run(self):
526
536
        from notify import NotifyPopupMenu
527
 
        gtk = self.open_display()
 
537
        gtk = open_display()
528
538
        menu = NotifyPopupMenu()
529
 
        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"))
530
540
        icon.connect('popup-menu', menu.display)
531
541
 
532
542
        import cgi
539
549
        from bzrlib.transport import get_transport
540
550
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
541
551
            import dbus.glib
542
 
        from bzrlib.plugins.dbus import activity
 
552
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
543
553
        bus = dbus.SessionBus()
544
 
        # get the object so we can subscribe to callbacks from it.
545
 
        broadcast_service = bus.get_object(
546
 
            activity.Broadcast.DBUS_NAME,
547
 
            activity.Broadcast.DBUS_PATH)
548
554
 
549
555
        def catch_branch(revision_id, urls):
550
556
            # TODO: show all the urls, or perhaps choose the 'best'.
581
587
            except Exception, e:
582
588
                print e
583
589
                raise
584
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
585
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
590
        bus.add_signal_receiver(catch_branch,
 
591
                                dbus_interface=BROADCAST_INTERFACE,
 
592
                                signal_name="Revision")
586
593
        pynotify.init("bzr commit-notify")
587
594
        gtk.main()
588
595
 
628
635
 
629
636
    takes_options = ['verbose',
630
637
                     Option('one', short_name='1',
631
 
                            help='stop when one test fails'),
632
 
                     Option('benchmark', help='run the benchmarks.'),
 
638
                            help='Stop when one test fails.'),
 
639
                     Option('benchmark', help='Run the benchmarks.'),
633
640
                     Option('lsprof-timed',
634
 
                     help='generate lsprof output for benchmarked'
 
641
                     help='Generate lsprof output for benchmarked'
635
642
                          ' sections of code.'),
636
643
                     Option('list-only',
637
 
                     help='list the tests instead of running them'),
 
644
                     help='List the tests instead of running them.'),
638
645
                     Option('randomize', type=str, argname="SEED",
639
 
                     help='randomize the order of tests using the given'
640
 
                          ' 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.'),
641
648
                    ]
642
649
    takes_args = ['testspecs*']
643
650
 
685
692
register_command(cmd_test_gtk)
686
693
 
687
694
 
 
695
 
688
696
import gettext
689
697
gettext.install('olive-gtk')
690
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
691
702
 
692
703
class NoDisplayError(BzrCommandError):
693
704
    """gtk could not find a proper display"""
703
714
    default_encoding = sys.getdefaultencoding()
704
715
    try:
705
716
        result = TestSuite()
 
717
        try:
 
718
            import_pygtk()
 
719
        except errors.BzrCommandError:
 
720
            return result
706
721
        result.addTest(tests.test_suite())
707
722
    finally:
708
723
        if sys.getdefaultencoding() != default_encoding: