/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

Reuse the viz treeview in the revision browser.

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, 94, 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)
 
47
required_bzrlib = (1, 0)
48
48
 
49
49
def check_bzrlib_version(desired):
50
50
    """Check that bzrlib is compatible.
77
77
    branch,
78
78
    builtins,
79
79
    errors,
80
 
    merge_directive,
81
80
    workingtree,
82
81
    )
83
82
""")
108
107
    return os.path.dirname(__file__)
109
108
 
110
109
 
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
110
class GTKCommand(Command):
134
111
    """Abstract class providing GTK specific run commands."""
135
112
 
 
113
    def open_display(self):
 
114
        pygtk = import_pygtk()
 
115
        try:
 
116
            import gtk
 
117
        except RuntimeError, e:
 
118
            if str(e) == "could not open display":
 
119
                raise NoDisplayError
 
120
        set_ui_factory()
 
121
        return gtk
 
122
 
136
123
    def run(self):
137
 
        open_display()
 
124
        self.open_display()
138
125
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
139
126
        dialog.run()
140
127
 
168
155
 
169
156
    def run(self, location="."):
170
157
        (br, path) = branch.Branch.open_containing(location)
171
 
        open_display()
 
158
        self.open_display()
172
159
        from push import PushDialog
173
160
        dialog = PushDialog(br.repository, br.last_revision(), br)
174
161
        dialog.run()
193
180
            if revision is not None:
194
181
                if len(revision) == 1:
195
182
                    tree1 = wt
196
 
                    revision_id = revision[0].as_revision_id(tree1.branch)
 
183
                    revision_id = revision[0].in_history(branch).rev_id
197
184
                    tree2 = branch.repository.revision_tree(revision_id)
198
185
                elif len(revision) == 2:
199
 
                    revision_id_0 = revision[0].as_revision_id(branch)
 
186
                    revision_id_0 = revision[0].in_history(branch).rev_id
200
187
                    tree2 = branch.repository.revision_tree(revision_id_0)
201
 
                    revision_id_1 = revision[1].as_revision_id(branch)
 
188
                    revision_id_1 = revision[1].in_history(branch).rev_id
202
189
                    tree1 = branch.repository.revision_tree(revision_id_1)
203
190
            else:
204
191
                tree1 = wt
226
213
            wt.unlock()
227
214
 
228
215
 
229
 
def start_viz_window(branch, revisions, limit=None):
 
216
def start_viz_window(branch, revision, limit=None):
230
217
    """Start viz on branch with revision revision.
231
218
    
232
219
    :return: The viz window object.
233
220
    """
234
221
    from viz import BranchWindow
235
 
    return BranchWindow(branch, revisions, limit)
 
222
    return BranchWindow(branch, revision, limit)
236
223
 
237
224
 
238
225
class cmd_visualise(Command):
248
235
        "revision",
249
236
        Option('limit', "Maximum number of revisions to display.",
250
237
               int, 'count')]
251
 
    takes_args = [ "locations*" ]
 
238
    takes_args = [ "location?" ]
252
239
    aliases = [ "visualize", "vis", "viz" ]
253
240
 
254
 
    def run(self, locations_list, revision=None, limit=None):
 
241
    def run(self, location=".", revision=None, limit=None):
255
242
        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))
 
243
        (br, path) = branch.Branch.open_containing(location)
 
244
        if revision is None:
 
245
            revid = br.last_revision()
 
246
            if revid is None:
 
247
                return
 
248
        else:
 
249
            (revno, revid) = revision[0].in_history(br)
 
250
 
265
251
        import gtk
266
 
        pp = start_viz_window(br, revids, limit)
 
252
        pp = start_viz_window(br, revid, limit)
267
253
        pp.connect("destroy", lambda w: gtk.main_quit())
268
254
        pp.show()
269
255
        gtk.main()
286
272
    aliases = ["gblame", "gpraise"]
287
273
    
288
274
    def run(self, filename, all=False, plain=False, line='1', revision=None):
289
 
        gtk = open_display()
 
275
        gtk = self.open_display()
290
276
 
291
277
        try:
292
278
            line = int(line)
311
297
        if revision is not None:
312
298
            if len(revision) != 1:
313
299
                raise BzrCommandError("Only 1 revion may be specified.")
314
 
            revision_id = revision[0].as_revision_id(br)
 
300
            revision_id = revision[0].in_history(br).rev_id
315
301
            tree = br.repository.revision_tree(revision_id)
316
302
        else:
317
303
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
318
304
 
319
 
        window = GAnnotateWindow(all, plain, branch=br)
 
305
        window = GAnnotateWindow(all, plain)
320
306
        window.connect("destroy", lambda w: gtk.main_quit())
 
307
        window.set_title(path + " - gannotate")
321
308
        config = GAnnotateConfig(window)
322
309
        window.show()
323
310
        br.lock_read()
345
332
 
346
333
    def run(self, filename=None):
347
334
        import os
348
 
        open_display()
 
335
        self.open_display()
349
336
        from commit import CommitDialog
350
337
        from bzrlib.errors import (BzrCommandError,
351
338
                                   NotBranchError,
358
345
            br = wt.branch
359
346
        except NoWorkingTree, e:
360
347
            from dialog import error_dialog
361
 
            error_dialog(_i18n('Directory does not have a working tree'),
362
 
                         _i18n('Operation aborted.'))
 
348
            error_dialog(_('Directory does not have a working tree'),
 
349
                         _('Operation aborted.'))
363
350
            return 1 # should this be retval=3?
364
351
 
365
352
        # It is a good habit to keep things locked for the duration, but it
382
369
    
383
370
    aliases = [ "gst" ]
384
371
    takes_args = ['PATH?']
385
 
    takes_options = ['revision']
 
372
    takes_options = []
386
373
 
387
 
    def run(self, path='.', revision=None):
 
374
    def run(self, path='.'):
388
375
        import os
389
 
        gtk = open_display()
 
376
        gtk = self.open_display()
390
377
        from status import StatusDialog
391
378
        (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)
 
379
        status = StatusDialog(wt, wt_path)
403
380
        status.connect("destroy", gtk.main_quit)
404
381
        status.run()
405
382
 
410
387
    """
411
388
    def run(self):
412
389
        (br, path) = branch.Branch.open_containing(".")
413
 
        gtk = open_display()
 
390
        gtk = self.open_display()
414
391
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
415
392
        from StringIO import StringIO
416
393
        dialog = SendMergeDirectiveDialog(br)
432
409
    """
433
410
    def run(self):
434
411
        (wt, path) = workingtree.WorkingTree.open_containing('.')
435
 
        open_display()
 
412
        self.open_display()
436
413
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
437
414
        dialog = ConflictsDialog(wt)
438
415
        dialog.run()
443
420
 
444
421
    """
445
422
    def run(self):
446
 
        open_display()
 
423
        self.open_display()
447
424
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
448
425
        dialog = PreferencesWindow()
449
426
        dialog.run()
487
464
 
488
465
class cmd_ginit(GTKCommand):
489
466
    def run(self):
490
 
        open_display()
 
467
        self.open_display()
491
468
        from initialize import InitDialog
492
469
        dialog = InitDialog(os.path.abspath(os.path.curdir))
493
470
        dialog.run()
497
474
    def run(self):
498
475
        br = branch.Branch.open_containing('.')[0]
499
476
        
500
 
        gtk = open_display()
 
477
        gtk = self.open_display()
501
478
        from tags import TagsWindow
502
479
        window = TagsWindow(br)
503
480
        window.show()
534
511
 
535
512
    def run(self):
536
513
        from notify import NotifyPopupMenu
537
 
        gtk = open_display()
 
514
        gtk = self.open_display()
538
515
        menu = NotifyPopupMenu()
539
 
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
 
516
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
540
517
        icon.connect('popup-menu', menu.display)
541
518
 
542
519
        import cgi
549
526
        from bzrlib.transport import get_transport
550
527
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
551
528
            import dbus.glib
552
 
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
 
529
        from bzrlib.plugins.dbus import activity
553
530
        bus = dbus.SessionBus()
 
531
        # get the object so we can subscribe to callbacks from it.
 
532
        broadcast_service = bus.get_object(
 
533
            activity.Broadcast.DBUS_NAME,
 
534
            activity.Broadcast.DBUS_PATH)
554
535
 
555
536
        def catch_branch(revision_id, urls):
556
537
            # TODO: show all the urls, or perhaps choose the 'best'.
587
568
            except Exception, e:
588
569
                print e
589
570
                raise
590
 
        bus.add_signal_receiver(catch_branch,
591
 
                                dbus_interface=BROADCAST_INTERFACE,
592
 
                                signal_name="Revision")
 
571
        broadcast_service.connect_to_signal("Revision", catch_branch,
 
572
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
593
573
        pynotify.init("bzr commit-notify")
594
574
        gtk.main()
595
575
 
692
672
register_command(cmd_test_gtk)
693
673
 
694
674
 
695
 
 
696
675
import gettext
697
676
gettext.install('olive-gtk')
698
677
 
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
678
 
703
679
class NoDisplayError(BzrCommandError):
704
680
    """gtk could not find a proper display"""