/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: Daniel Schierbeck
  • Date: 2007-11-02 14:49:57 UTC
  • mto: (330.6.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 341.
  • Revision ID: daniel.schierbeck@gmail.com-20071102144957-8r4lp70ma5bpk8r8
Renamed logview 'revisionview'.

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