/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

Merge Johns' gcommit improvements and fix conflicts against trunk.

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