/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:31:29 UTC
  • mto: This revision was merged to the branch mainline in revision 518.
  • Revision ID: jelmer@samba.org-20080629183129-syqvz3xm5gqagzsx
https://launchpad.net/bugs/244025
Fix use of smart_add.

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