/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
  • Author(s): Kiddo
  • Date: 2007-11-28 18:00:03 UTC
  • mto: This revision was merged to the branch mainline in revision 410.
  • Revision ID: jelmer@samba.org-20071128180003-oq0m5cfuab52ekk1
Make toolbars follow GNOME standards.

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, 95, 0, 'dev', 1)
 
39
version_info = (0, 93, 0, 'dev', 0)
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
 
 
49
47
def check_bzrlib_version(desired):
50
48
    """Check that bzrlib is compatible.
51
49
 
52
50
    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.
53
54
    """
 
55
    desired_plus = (desired[0], desired[1]+1)
54
56
    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
55
60
    try:
56
61
        from bzrlib.trace import warning
57
62
    except ImportError:
62
67
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
63
68
                ' %s.' % (bzrlib.__version__, __version__))
64
69
        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]))
65
74
 
66
75
 
67
76
if version_info[2] == "final":
68
 
    check_bzrlib_version(required_bzrlib)
 
77
    check_bzrlib_version(version_info[:2])
69
78
 
70
79
from bzrlib.trace import warning
71
80
if __name__ != 'bzrlib.plugins.gtk':
77
86
    branch,
78
87
    builtins,
79
88
    errors,
80
 
    merge_directive,
81
89
    workingtree,
82
90
    )
83
91
""")
108
116
    return os.path.dirname(__file__)
109
117
 
110
118
 
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
119
class GTKCommand(Command):
134
120
    """Abstract class providing GTK specific run commands."""
135
121
 
 
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
 
136
132
    def run(self):
137
 
        open_display()
 
133
        self.open_display()
138
134
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
139
135
        dialog.run()
140
136
 
168
164
 
169
165
    def run(self, location="."):
170
166
        (br, path) = branch.Branch.open_containing(location)
171
 
        open_display()
 
167
        self.open_display()
172
168
        from push import PushDialog
173
169
        dialog = PushDialog(br.repository, br.last_revision(), br)
174
170
        dialog.run()
193
189
            if revision is not None:
194
190
                if len(revision) == 1:
195
191
                    tree1 = wt
196
 
                    revision_id = revision[0].as_revision_id(tree1.branch)
 
192
                    revision_id = revision[0].in_history(branch).rev_id
197
193
                    tree2 = branch.repository.revision_tree(revision_id)
198
194
                elif len(revision) == 2:
199
 
                    revision_id_0 = revision[0].as_revision_id(branch)
 
195
                    revision_id_0 = revision[0].in_history(branch).rev_id
200
196
                    tree2 = branch.repository.revision_tree(revision_id_0)
201
 
                    revision_id_1 = revision[1].as_revision_id(branch)
 
197
                    revision_id_1 = revision[1].in_history(branch).rev_id
202
198
                    tree1 = branch.repository.revision_tree(revision_id_1)
203
199
            else:
204
200
                tree1 = wt
226
222
            wt.unlock()
227
223
 
228
224
 
229
 
def start_viz_window(branch, revisions, limit=None):
 
225
def start_viz_window(branch, revision, limit=None):
230
226
    """Start viz on branch with revision revision.
231
227
    
232
228
    :return: The viz window object.
233
229
    """
234
 
    from viz import BranchWindow
235
 
    return BranchWindow(branch, revisions, limit)
 
230
    from viz.branchwin import BranchWindow
 
231
    return BranchWindow(branch, revision, limit)
236
232
 
237
233
 
238
234
class cmd_visualise(Command):
248
244
        "revision",
249
245
        Option('limit', "Maximum number of revisions to display.",
250
246
               int, 'count')]
251
 
    takes_args = [ "locations*" ]
 
247
    takes_args = [ "location?" ]
252
248
    aliases = [ "visualize", "vis", "viz" ]
253
249
 
254
 
    def run(self, locations_list, revision=None, limit=None):
 
250
    def run(self, location=".", revision=None, limit=None):
255
251
        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)
 
252
        (br, path) = branch.Branch.open_containing(location)
 
253
        br.lock_read()
 
254
        try:
261
255
            if revision is None:
262
 
                revids.append(br.last_revision())
 
256
                revid = br.last_revision()
 
257
                if revid is None:
 
258
                    return
263
259
            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()
 
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()
270
269
 
271
270
 
272
271
class cmd_gannotate(GTKCommand):
286
285
    aliases = ["gblame", "gpraise"]
287
286
    
288
287
    def run(self, filename, all=False, plain=False, line='1', revision=None):
289
 
        gtk = open_display()
 
288
        gtk = self.open_display()
290
289
 
291
290
        try:
292
291
            line = int(line)
311
310
        if revision is not None:
312
311
            if len(revision) != 1:
313
312
                raise BzrCommandError("Only 1 revion may be specified.")
314
 
            revision_id = revision[0].as_revision_id(br)
 
313
            revision_id = revision[0].in_history(br).rev_id
315
314
            tree = br.repository.revision_tree(revision_id)
316
315
        else:
317
316
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
318
317
 
319
 
        window = GAnnotateWindow(all, plain, branch=br)
 
318
        window = GAnnotateWindow(all, plain)
320
319
        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
 
        open_display()
 
348
        self.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(_i18n('Directory does not have a working tree'),
362
 
                         _i18n('Operation aborted.'))
 
361
            error_dialog(_('Directory does not have a working tree'),
 
362
                         _('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 = ['revision']
 
385
    takes_options = []
386
386
 
387
 
    def run(self, path='.', revision=None):
 
387
    def run(self, path='.'):
388
388
        import os
389
 
        gtk = open_display()
 
389
        gtk = self.open_display()
390
390
        from status import StatusDialog
391
391
        (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)
 
392
        status = StatusDialog(wt, wt_path)
403
393
        status.connect("destroy", gtk.main_quit)
404
394
        status.run()
405
395
 
410
400
    """
411
401
    def run(self):
412
402
        (br, path) = branch.Branch.open_containing(".")
413
 
        gtk = open_display()
 
403
        gtk = self.open_display()
414
404
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
415
405
        from StringIO import StringIO
416
406
        dialog = SendMergeDirectiveDialog(br)
432
422
    """
433
423
    def run(self):
434
424
        (wt, path) = workingtree.WorkingTree.open_containing('.')
435
 
        open_display()
 
425
        self.open_display()
436
426
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
437
427
        dialog = ConflictsDialog(wt)
438
428
        dialog.run()
443
433
 
444
434
    """
445
435
    def run(self):
446
 
        open_display()
 
436
        self.open_display()
447
437
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
448
438
        dialog = PreferencesWindow()
449
439
        dialog.run()
487
477
 
488
478
class cmd_ginit(GTKCommand):
489
479
    def run(self):
490
 
        open_display()
 
480
        self.open_display()
491
481
        from initialize import InitDialog
492
482
        dialog = InitDialog(os.path.abspath(os.path.curdir))
493
483
        dialog.run()
497
487
    def run(self):
498
488
        br = branch.Branch.open_containing('.')[0]
499
489
        
500
 
        gtk = open_display()
 
490
        gtk = self.open_display()
501
491
        from tags import TagsWindow
502
492
        window = TagsWindow(br)
503
493
        window.show()
534
524
 
535
525
    def run(self):
536
526
        from notify import NotifyPopupMenu
537
 
        gtk = open_display()
 
527
        gtk = self.open_display()
538
528
        menu = NotifyPopupMenu()
539
 
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
 
529
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
540
530
        icon.connect('popup-menu', menu.display)
541
531
 
542
532
        import cgi
549
539
        from bzrlib.transport import get_transport
550
540
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
551
541
            import dbus.glib
552
 
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
 
542
        from bzrlib.plugins.dbus import activity
553
543
        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)
554
548
 
555
549
        def catch_branch(revision_id, urls):
556
550
            # TODO: show all the urls, or perhaps choose the 'best'.
587
581
            except Exception, e:
588
582
                print e
589
583
                raise
590
 
        bus.add_signal_receiver(catch_branch,
591
 
                                dbus_interface=BROADCAST_INTERFACE,
592
 
                                signal_name="Revision")
 
584
        broadcast_service.connect_to_signal("Revision", catch_branch,
 
585
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
593
586
        pynotify.init("bzr commit-notify")
594
587
        gtk.main()
595
588
 
692
685
register_command(cmd_test_gtk)
693
686
 
694
687
 
695
 
 
696
688
import gettext
697
689
gettext.install('olive-gtk')
698
690
 
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
691
 
703
692
class NoDisplayError(BzrCommandError):
704
693
    """gtk could not find a proper display"""