/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: John Arbash Meinel
  • Date: 2007-10-01 17:41:53 UTC
  • mto: (322.1.1 trunk) (330.3.3 trunk)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: john@arbash-meinel.com-20071001174153-6xoqsds4hnv291l3
Adding some prototypes of how the commit should look

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
25
ginit             Initialise a new branch.
26
26
gmissing          GTK+ missing revisions dialog. 
27
27
gpreferences      GTK+ preferences dialog. 
28
 
gpush             GTK+ push.
29
 
gsend             GTK+ send merge directive.
30
 
gstatus           GTK+ status dialog.
 
28
gpush             GTK+ push. 
 
29
gstatus           GTK+ status dialog 
31
30
gtags             Manage branch tags.
32
31
visualise         Graphically visualise this branch. 
33
32
"""
34
33
 
35
 
import sys
36
 
 
37
34
import bzrlib
38
35
 
39
 
version_info = (0, 95, 0, 'dev', 1)
 
36
version_info = (0, 92, 0, 'dev', 0)
40
37
 
41
38
if version_info[3] == 'final':
42
39
    version_string = '%d.%d.%d' % version_info[:3]
44
41
    version_string = '%d.%d.%d%s%d' % version_info
45
42
__version__ = version_string
46
43
 
47
 
required_bzrlib = (1, 3)
48
 
 
49
44
def check_bzrlib_version(desired):
50
45
    """Check that bzrlib is compatible.
51
46
 
52
47
    If version is < bzr-gtk version, assume incompatible.
 
48
    If version == bzr-gtk version, assume completely compatible
 
49
    If version == bzr-gtk version + 1, assume compatible, with deprecations
 
50
    Otherwise, assume incompatible.
53
51
    """
 
52
    desired_plus = (desired[0], desired[1]+1)
54
53
    bzrlib_version = bzrlib.version_info[:2]
 
54
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
 
55
                                     bzrlib.version_info[3] == 'dev'):
 
56
        return
55
57
    try:
56
58
        from bzrlib.trace import warning
57
59
    except ImportError:
62
64
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
63
65
                ' %s.' % (bzrlib.__version__, __version__))
64
66
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
 
67
    else:
 
68
        warning('bzr-gtk is not up to date with installed bzr version %s.'
 
69
                ' \nThere should be a newer version available, e.g. %i.%i.' 
 
70
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
65
71
 
66
72
 
67
73
if version_info[2] == "final":
68
 
    check_bzrlib_version(required_bzrlib)
 
74
    check_bzrlib_version(version_info[:2])
69
75
 
70
76
from bzrlib.trace import warning
71
77
if __name__ != 'bzrlib.plugins.gtk':
77
83
    branch,
78
84
    builtins,
79
85
    errors,
80
 
    merge_directive,
81
86
    workingtree,
82
87
    )
83
88
""")
108
113
    return os.path.dirname(__file__)
109
114
 
110
115
 
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
116
class GTKCommand(Command):
134
117
    """Abstract class providing GTK specific run commands."""
135
118
 
 
119
    def open_display(self):
 
120
        pygtk = import_pygtk()
 
121
        try:
 
122
            import gtk
 
123
        except RuntimeError, e:
 
124
            if str(e) == "could not open display":
 
125
                raise NoDisplayError
 
126
        set_ui_factory()
 
127
        return gtk
 
128
 
136
129
    def run(self):
137
 
        open_display()
 
130
        self.open_display()
138
131
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
139
132
        dialog.run()
140
133
 
168
161
 
169
162
    def run(self, location="."):
170
163
        (br, path) = branch.Branch.open_containing(location)
171
 
        open_display()
 
164
        self.open_display()
172
165
        from push import PushDialog
173
166
        dialog = PushDialog(br.repository, br.last_revision(), br)
174
167
        dialog.run()
193
186
            if revision is not None:
194
187
                if len(revision) == 1:
195
188
                    tree1 = wt
196
 
                    revision_id = revision[0].as_revision_id(tree1.branch)
 
189
                    revision_id = revision[0].in_history(branch).rev_id
197
190
                    tree2 = branch.repository.revision_tree(revision_id)
198
191
                elif len(revision) == 2:
199
 
                    revision_id_0 = revision[0].as_revision_id(branch)
 
192
                    revision_id_0 = revision[0].in_history(branch).rev_id
200
193
                    tree2 = branch.repository.revision_tree(revision_id_0)
201
 
                    revision_id_1 = revision[1].as_revision_id(branch)
 
194
                    revision_id_1 = revision[1].in_history(branch).rev_id
202
195
                    tree1 = branch.repository.revision_tree(revision_id_1)
203
196
            else:
204
197
                tree1 = wt
226
219
            wt.unlock()
227
220
 
228
221
 
229
 
def start_viz_window(branch, revisions, limit=None):
 
222
def start_viz_window(branch, revision, limit=None):
230
223
    """Start viz on branch with revision revision.
231
224
    
232
225
    :return: The viz window object.
233
226
    """
234
 
    from viz import BranchWindow
235
 
    return BranchWindow(branch, revisions, limit)
 
227
    from viz.branchwin import BranchWindow
 
228
    branch.lock_read()
 
229
    pp = BranchWindow()
 
230
    pp.set_branch(branch, revision, limit)
 
231
    # cleanup locks when the window is closed
 
232
    pp.connect("destroy", lambda w: branch.unlock())
 
233
    return pp
236
234
 
237
235
 
238
236
class cmd_visualise(Command):
248
246
        "revision",
249
247
        Option('limit', "Maximum number of revisions to display.",
250
248
               int, 'count')]
251
 
    takes_args = [ "locations*" ]
 
249
    takes_args = [ "location?" ]
252
250
    aliases = [ "visualize", "vis", "viz" ]
253
251
 
254
 
    def run(self, locations_list, revision=None, limit=None):
 
252
    def run(self, location=".", revision=None, limit=None):
255
253
        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)
 
254
        (br, path) = branch.Branch.open_containing(location)
 
255
        br.lock_read()
 
256
        try:
261
257
            if revision is None:
262
 
                revids.append(br.last_revision())
 
258
                revid = br.last_revision()
 
259
                if revid is None:
 
260
                    return
263
261
            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()
 
262
                (revno, revid) = revision[0].in_history(br)
 
263
 
 
264
            import gtk
 
265
            pp = start_viz_window(br, revid, limit)
 
266
            pp.connect("destroy", lambda w: gtk.main_quit())
 
267
            pp.show()
 
268
            gtk.main()
 
269
        finally:
 
270
            br.unlock()
270
271
 
271
272
 
272
273
class cmd_gannotate(GTKCommand):
286
287
    aliases = ["gblame", "gpraise"]
287
288
    
288
289
    def run(self, filename, all=False, plain=False, line='1', revision=None):
289
 
        gtk = open_display()
 
290
        gtk = self.open_display()
290
291
 
291
292
        try:
292
293
            line = int(line)
311
312
        if revision is not None:
312
313
            if len(revision) != 1:
313
314
                raise BzrCommandError("Only 1 revion may be specified.")
314
 
            revision_id = revision[0].as_revision_id(br)
 
315
            revision_id = revision[0].in_history(br).rev_id
315
316
            tree = br.repository.revision_tree(revision_id)
316
317
        else:
317
318
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
318
319
 
319
 
        window = GAnnotateWindow(all, plain, branch=br)
 
320
        window = GAnnotateWindow(all, plain)
320
321
        window.connect("destroy", lambda w: gtk.main_quit())
 
322
        window.set_title(path + " - gannotate")
321
323
        config = GAnnotateConfig(window)
322
324
        window.show()
323
325
        br.lock_read()
345
347
 
346
348
    def run(self, filename=None):
347
349
        import os
348
 
        open_display()
 
350
        self.open_display()
349
351
        from commit import CommitDialog
350
352
        from bzrlib.errors import (BzrCommandError,
351
353
                                   NotBranchError,
358
360
            br = wt.branch
359
361
        except NoWorkingTree, e:
360
362
            from dialog import error_dialog
361
 
            error_dialog(_i18n('Directory does not have a working tree'),
362
 
                         _i18n('Operation aborted.'))
 
363
            error_dialog(_('Directory does not have a working tree'),
 
364
                         _('Operation aborted.'))
363
365
            return 1 # should this be retval=3?
364
366
 
365
367
        # It is a good habit to keep things locked for the duration, but it
382
384
    
383
385
    aliases = [ "gst" ]
384
386
    takes_args = ['PATH?']
385
 
    takes_options = ['revision']
 
387
    takes_options = []
386
388
 
387
 
    def run(self, path='.', revision=None):
 
389
    def run(self, path='.'):
388
390
        import os
389
 
        gtk = open_display()
 
391
        gtk = self.open_display()
390
392
        from status import StatusDialog
391
393
        (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)
 
394
        status = StatusDialog(wt, wt_path)
403
395
        status.connect("destroy", gtk.main_quit)
404
396
        status.run()
405
397
 
406
398
 
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 = 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
 
 
426
399
 
427
400
class cmd_gconflicts(GTKCommand):
428
 
    """GTK+ conflicts.
 
401
    """ GTK+ conflicts.
429
402
    
430
403
    Select files from the list of conflicts and run an external utility to
431
404
    resolve them.
432
405
    """
433
406
    def run(self):
434
407
        (wt, path) = workingtree.WorkingTree.open_containing('.')
435
 
        open_display()
 
408
        self.open_display()
436
409
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
437
410
        dialog = ConflictsDialog(wt)
438
411
        dialog.run()
439
412
 
440
413
 
 
414
 
441
415
class cmd_gpreferences(GTKCommand):
442
416
    """ GTK+ preferences dialog.
443
417
 
444
418
    """
445
419
    def run(self):
446
 
        open_display()
 
420
        self.open_display()
447
421
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
448
422
        dialog = PreferencesWindow()
449
423
        dialog.run()
450
424
 
451
425
 
 
426
 
452
427
class cmd_gmissing(Command):
453
428
    """ GTK+ missing revisions dialog.
454
429
 
487
462
 
488
463
class cmd_ginit(GTKCommand):
489
464
    def run(self):
490
 
        open_display()
 
465
        self.open_display()
491
466
        from initialize import InitDialog
492
467
        dialog = InitDialog(os.path.abspath(os.path.curdir))
493
468
        dialog.run()
497
472
    def run(self):
498
473
        br = branch.Branch.open_containing('.')[0]
499
474
        
500
 
        gtk = open_display()
 
475
        gtk = self.open_display()
501
476
        from tags import TagsWindow
502
477
        window = TagsWindow(br)
503
478
        window.show()
505
480
 
506
481
 
507
482
commands = [
 
483
    cmd_gmissing, 
 
484
    cmd_gpreferences, 
 
485
    cmd_gconflicts, 
 
486
    cmd_gstatus,
 
487
    cmd_gcommit, 
508
488
    cmd_gannotate, 
 
489
    cmd_visualise, 
 
490
    cmd_gdiff,
 
491
    cmd_gpush, 
 
492
    cmd_gcheckout, 
509
493
    cmd_gbranch,
510
 
    cmd_gcheckout, 
511
 
    cmd_gcommit, 
512
 
    cmd_gconflicts, 
513
 
    cmd_gdiff,
514
494
    cmd_ginit,
515
 
    cmd_gmissing, 
516
 
    cmd_gpreferences, 
517
 
    cmd_gpush, 
518
 
    cmd_gsend,
519
 
    cmd_gstatus,
520
 
    cmd_gtags,
521
 
    cmd_visualise
 
495
    cmd_gtags
522
496
    ]
523
497
 
524
498
for cmd in commands:
534
508
 
535
509
    def run(self):
536
510
        from notify import NotifyPopupMenu
537
 
        gtk = open_display()
 
511
        gtk = self.open_display()
538
512
        menu = NotifyPopupMenu()
539
 
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
 
513
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
540
514
        icon.connect('popup-menu', menu.display)
541
515
 
542
516
        import cgi
549
523
        from bzrlib.transport import get_transport
550
524
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
551
525
            import dbus.glib
552
 
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
 
526
        from bzrlib.plugins.dbus import activity
553
527
        bus = dbus.SessionBus()
 
528
        # get the object so we can subscribe to callbacks from it.
 
529
        broadcast_service = bus.get_object(
 
530
            activity.Broadcast.DBUS_NAME,
 
531
            activity.Broadcast.DBUS_PATH)
554
532
 
555
533
        def catch_branch(revision_id, urls):
556
534
            # TODO: show all the urls, or perhaps choose the 'best'.
587
565
            except Exception, e:
588
566
                print e
589
567
                raise
590
 
        bus.add_signal_receiver(catch_branch,
591
 
                                dbus_interface=BROADCAST_INTERFACE,
592
 
                                signal_name="Revision")
 
568
        broadcast_service.connect_to_signal("Revision", catch_branch,
 
569
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
593
570
        pynotify.init("bzr commit-notify")
594
571
        gtk.main()
595
572
 
630
607
register_command(cmd_gselftest)
631
608
 
632
609
 
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
610
import gettext
697
611
gettext.install('olive-gtk')
698
612
 
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
613
 
703
614
class NoDisplayError(BzrCommandError):
704
615
    """gtk could not find a proper display"""
714
625
    default_encoding = sys.getdefaultencoding()
715
626
    try:
716
627
        result = TestSuite()
717
 
        try:
718
 
            import_pygtk()
719
 
        except errors.BzrCommandError:
720
 
            return result
721
628
        result.addTest(tests.test_suite())
722
629
    finally:
723
630
        if sys.getdefaultencoding() != default_encoding: