/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: Aaron Bentley
  • Date: 2008-02-23 06:39:14 UTC
  • Revision ID: aaron@aaronbentley.com-20080223063914-49gdt7ed630rug9b
Add handle-patch script

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