/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-12-06 23:37:06 UTC
  • mto: This revision was merged to the branch mainline in revision 417.
  • Revision ID: daniel.schierbeck@gmail.com-20071206233706-eeinks66w86r3gfm
Fixed bug in gmissing.

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)
261
 
            if revision is None:
262
 
                revids.append(br.last_revision())
263
 
            else:
264
 
                revids.append(revision[0].as_revision_id(br))
 
252
        (br, path) = branch.Branch.open_containing(location)
 
253
        if revision is None:
 
254
            revid = br.last_revision()
 
255
            if revid is None:
 
256
                return
 
257
        else:
 
258
            (revno, revid) = revision[0].in_history(br)
 
259
 
265
260
        import gtk
266
 
        pp = start_viz_window(br, revids, limit)
 
261
        pp = start_viz_window(br, revid, limit)
267
262
        pp.connect("destroy", lambda w: gtk.main_quit())
268
263
        pp.show()
269
264
        gtk.main()
286
281
    aliases = ["gblame", "gpraise"]
287
282
    
288
283
    def run(self, filename, all=False, plain=False, line='1', revision=None):
289
 
        gtk = open_display()
 
284
        gtk = self.open_display()
290
285
 
291
286
        try:
292
287
            line = int(line)
311
306
        if revision is not None:
312
307
            if len(revision) != 1:
313
308
                raise BzrCommandError("Only 1 revion may be specified.")
314
 
            revision_id = revision[0].as_revision_id(br)
 
309
            revision_id = revision[0].in_history(br).rev_id
315
310
            tree = br.repository.revision_tree(revision_id)
316
311
        else:
317
312
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
318
313
 
319
 
        window = GAnnotateWindow(all, plain, branch=br)
 
314
        window = GAnnotateWindow(all, plain)
320
315
        window.connect("destroy", lambda w: gtk.main_quit())
 
316
        window.set_title(path + " - gannotate")
321
317
        config = GAnnotateConfig(window)
322
318
        window.show()
323
319
        br.lock_read()
345
341
 
346
342
    def run(self, filename=None):
347
343
        import os
348
 
        open_display()
 
344
        self.open_display()
349
345
        from commit import CommitDialog
350
346
        from bzrlib.errors import (BzrCommandError,
351
347
                                   NotBranchError,
358
354
            br = wt.branch
359
355
        except NoWorkingTree, e:
360
356
            from dialog import error_dialog
361
 
            error_dialog(_i18n('Directory does not have a working tree'),
362
 
                         _i18n('Operation aborted.'))
 
357
            error_dialog(_('Directory does not have a working tree'),
 
358
                         _('Operation aborted.'))
363
359
            return 1 # should this be retval=3?
364
360
 
365
361
        # It is a good habit to keep things locked for the duration, but it
382
378
    
383
379
    aliases = [ "gst" ]
384
380
    takes_args = ['PATH?']
385
 
    takes_options = ['revision']
 
381
    takes_options = []
386
382
 
387
 
    def run(self, path='.', revision=None):
 
383
    def run(self, path='.'):
388
384
        import os
389
 
        gtk = open_display()
 
385
        gtk = self.open_display()
390
386
        from status import StatusDialog
391
387
        (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)
 
388
        status = StatusDialog(wt, wt_path)
403
389
        status.connect("destroy", gtk.main_quit)
404
390
        status.run()
405
391
 
410
396
    """
411
397
    def run(self):
412
398
        (br, path) = branch.Branch.open_containing(".")
413
 
        gtk = open_display()
 
399
        gtk = self.open_display()
414
400
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
415
401
        from StringIO import StringIO
416
402
        dialog = SendMergeDirectiveDialog(br)
432
418
    """
433
419
    def run(self):
434
420
        (wt, path) = workingtree.WorkingTree.open_containing('.')
435
 
        open_display()
 
421
        self.open_display()
436
422
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
437
423
        dialog = ConflictsDialog(wt)
438
424
        dialog.run()
443
429
 
444
430
    """
445
431
    def run(self):
446
 
        open_display()
 
432
        self.open_display()
447
433
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
448
434
        dialog = PreferencesWindow()
449
435
        dialog.run()
487
473
 
488
474
class cmd_ginit(GTKCommand):
489
475
    def run(self):
490
 
        open_display()
 
476
        self.open_display()
491
477
        from initialize import InitDialog
492
478
        dialog = InitDialog(os.path.abspath(os.path.curdir))
493
479
        dialog.run()
497
483
    def run(self):
498
484
        br = branch.Branch.open_containing('.')[0]
499
485
        
500
 
        gtk = open_display()
 
486
        gtk = self.open_display()
501
487
        from tags import TagsWindow
502
488
        window = TagsWindow(br)
503
489
        window.show()
534
520
 
535
521
    def run(self):
536
522
        from notify import NotifyPopupMenu
537
 
        gtk = open_display()
 
523
        gtk = self.open_display()
538
524
        menu = NotifyPopupMenu()
539
 
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
 
525
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
540
526
        icon.connect('popup-menu', menu.display)
541
527
 
542
528
        import cgi
549
535
        from bzrlib.transport import get_transport
550
536
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
551
537
            import dbus.glib
552
 
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
 
538
        from bzrlib.plugins.dbus import activity
553
539
        bus = dbus.SessionBus()
 
540
        # get the object so we can subscribe to callbacks from it.
 
541
        broadcast_service = bus.get_object(
 
542
            activity.Broadcast.DBUS_NAME,
 
543
            activity.Broadcast.DBUS_PATH)
554
544
 
555
545
        def catch_branch(revision_id, urls):
556
546
            # TODO: show all the urls, or perhaps choose the 'best'.
587
577
            except Exception, e:
588
578
                print e
589
579
                raise
590
 
        bus.add_signal_receiver(catch_branch,
591
 
                                dbus_interface=BROADCAST_INTERFACE,
592
 
                                signal_name="Revision")
 
580
        broadcast_service.connect_to_signal("Revision", catch_branch,
 
581
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
593
582
        pynotify.init("bzr commit-notify")
594
583
        gtk.main()
595
584
 
692
681
register_command(cmd_test_gtk)
693
682
 
694
683
 
695
 
 
696
684
import gettext
697
685
gettext.install('olive-gtk')
698
686
 
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
687
 
703
688
class NoDisplayError(BzrCommandError):
704
689
    """gtk could not find a proper display"""