/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: Szilveszter Farkas (Phanatic)
  • Date: 2007-03-15 12:43:48 UTC
  • mto: (126.1.38 bzr-gtk)
  • mto: This revision was merged to the branch mainline in revision 172.
  • Revision ID: szilveszter.farkas@gmail.com-20070315124348-0nx0zb7fv4pa8xk6
Fix the indentation error in the TortoiseBZR test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
12
12
# along with this program; if not, write to the Free Software
13
13
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
14
14
 
15
 
"""Graphical support for Bazaar using GTK.
16
 
 
17
 
This plugin includes:
18
 
commit-notify     Start the graphical notifier of commits.
19
 
gannotate         GTK+ annotate. 
20
 
gbranch           GTK+ branching. 
21
 
gcheckout         GTK+ checkout. 
22
 
gcommit           GTK+ commit dialog 
23
 
gconflicts        GTK+ push. 
24
 
gdiff             Show differences in working tree in a GTK+ Window. 
25
 
ginit             Initialise a new branch.
26
 
gmissing          GTK+ missing revisions dialog. 
27
 
gpreferences      GTK+ preferences dialog. 
28
 
gpush             GTK+ push. 
29
 
gstatus           GTK+ status dialog 
30
 
gtags             Manage branch tags.
31
 
visualise         Graphically visualise this branch. 
32
 
"""
 
15
"""GTK+ frontends to Bazaar commands """
33
16
 
34
17
import bzrlib
35
18
 
36
 
__version__ = '0.19.0'
 
19
__version__ = '0.16.0'
37
20
version_info = tuple(int(n) for n in __version__.split('.'))
38
21
 
39
22
 
47
30
    """
48
31
    desired_plus = (desired[0], desired[1]+1)
49
32
    bzrlib_version = bzrlib.version_info[:2]
50
 
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
51
 
                                     bzrlib.version_info[3] == 'dev'):
 
33
    if bzrlib_version == desired:
52
34
        return
53
35
    try:
54
36
        from bzrlib.trace import warning
56
38
        # get the message out any way we can
57
39
        from warnings import warn as warning
58
40
    if bzrlib_version < desired:
59
 
        from bzrlib.errors import BzrError
60
41
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
61
42
                ' %s.' % (bzrlib.__version__, __version__))
62
 
        raise BzrError('Version mismatch: %r' % version_info)
 
43
        # Not using BzrNewError, because it may not exist.
 
44
        raise Exception, ('Version mismatch', version_info)
63
45
    else:
64
46
        warning('bzr-gtk is not up to date with installed bzr version %s.'
65
47
                ' \nThere should be a newer version available, e.g. %i.%i.' 
66
48
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
 
49
        if bzrlib_version != desired_plus:
 
50
            raise Exception, 'Version mismatch'
67
51
 
68
52
 
69
53
check_bzrlib_version(version_info[:2])
76
60
lazy_import(globals(), """
77
61
from bzrlib import (
78
62
    branch,
79
 
    builtins,
80
63
    errors,
81
64
    workingtree,
82
65
    )
84
67
 
85
68
from bzrlib.commands import Command, register_command, display_command
86
69
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
 
70
from bzrlib.commands import Command, register_command
87
71
from bzrlib.option import Option
 
72
from bzrlib.bzrdir import BzrDir
88
73
 
89
74
import os.path
90
75
 
98
83
 
99
84
 
100
85
def set_ui_factory():
101
 
    import_pygtk()
 
86
    pygtk = import_pygtk()
102
87
    from ui import GtkUIFactory
103
88
    import bzrlib.ui
104
89
    bzrlib.ui.ui_factory = GtkUIFactory()
105
90
 
106
91
 
107
 
def data_path():
108
 
    return os.path.dirname(__file__)
109
 
 
110
 
 
111
 
class GTKCommand(Command):
112
 
    """Abstract class providing GTK specific run commands."""
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
 
 
124
 
    def run(self):
125
 
        self.open_display()
126
 
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
127
 
        dialog.run()
128
 
 
129
 
 
130
 
class cmd_gbranch(GTKCommand):
 
92
class cmd_gbranch(Command):
131
93
    """GTK+ branching.
132
94
    
133
95
    """
134
96
 
135
 
    def get_gtk_dialog(self, path):
 
97
    def run(self):
 
98
        pygtk = import_pygtk()
 
99
        try:
 
100
            import gtk
 
101
        except RuntimeError, e:
 
102
            if str(e) == "could not open display":
 
103
                raise NoDisplayError
 
104
 
136
105
        from bzrlib.plugins.gtk.branch import BranchDialog
137
 
        return BranchDialog(path)
138
 
 
139
 
 
140
 
class cmd_gcheckout(GTKCommand):
 
106
 
 
107
        set_ui_factory()
 
108
        dialog = BranchDialog(os.path.abspath('.'))
 
109
        dialog.run()
 
110
 
 
111
register_command(cmd_gbranch)
 
112
 
 
113
class cmd_gcheckout(Command):
141
114
    """ GTK+ checkout.
142
115
    
143
116
    """
144
117
    
145
 
    def get_gtk_dialog(self, path):
 
118
    def run(self):
 
119
        pygtk = import_pygtk()
 
120
        try:
 
121
            import gtk
 
122
        except RuntimeError, e:
 
123
            if str(e) == "could not open display":
 
124
                raise NoDisplayError
 
125
 
146
126
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
147
 
        return CheckoutDialog(path)
148
 
 
149
 
 
150
 
 
151
 
class cmd_gpush(GTKCommand):
 
127
 
 
128
        set_ui_factory()
 
129
        dialog = CheckoutDialog(os.path.abspath('.'))
 
130
        dialog.run()
 
131
 
 
132
register_command(cmd_gcheckout)
 
133
 
 
134
class cmd_gpush(Command):
152
135
    """ GTK+ push.
153
136
    
154
137
    """
156
139
 
157
140
    def run(self, location="."):
158
141
        (br, path) = branch.Branch.open_containing(location)
159
 
        self.open_display()
 
142
 
 
143
        pygtk = import_pygtk()
 
144
        try:
 
145
            import gtk
 
146
        except RuntimeError, e:
 
147
            if str(e) == "could not open display":
 
148
                raise NoDisplayError
 
149
 
160
150
        from push import PushDialog
161
 
        dialog = PushDialog(br.repository, br.last_revision(), br)
 
151
 
 
152
        set_ui_factory()
 
153
        dialog = PushDialog(br)
162
154
        dialog.run()
163
155
 
164
 
 
165
 
 
166
 
class cmd_gdiff(GTKCommand):
 
156
register_command(cmd_gpush)
 
157
 
 
158
class cmd_gdiff(Command):
167
159
    """Show differences in working tree in a GTK+ Window.
168
160
    
169
161
    Otherwise, all changes for the tree are listed.
202
194
                try:
203
195
                    window.set_file(tree_filename)
204
196
                except NoSuchFile:
205
 
                    if (tree1.path2id(tree_filename) is None and 
206
 
                        tree2.path2id(tree_filename) is None):
 
197
                    if (tree1.inventory.path2id(tree_filename) is None and 
 
198
                        tree2.inventory.path2id(tree_filename) is None):
207
199
                        raise NotVersionedError(filename)
208
200
                    raise BzrCommandError('No changes found for file "%s"' % 
209
201
                                          filename)
213
205
        finally:
214
206
            wt.unlock()
215
207
 
216
 
 
217
 
def start_viz_window(branch, revision, limit=None):
218
 
    """Start viz on branch with revision revision.
219
 
    
220
 
    :return: The viz window object.
221
 
    """
222
 
    from viz.branchwin import BranchWindow
223
 
    branch.lock_read()
224
 
    pp = BranchWindow()
225
 
    pp.set_branch(branch, revision, limit)
226
 
    # cleanup locks when the window is closed
227
 
    pp.connect("destroy", lambda w: branch.unlock())
228
 
    return pp
229
 
 
 
208
register_command(cmd_gdiff)
230
209
 
231
210
class cmd_visualise(Command):
232
211
    """Graphically visualise this branch.
239
218
    """
240
219
    takes_options = [
241
220
        "revision",
242
 
        Option('limit', "Maximum number of revisions to display.",
 
221
        Option('limit', "maximum number of revisions to display",
243
222
               int, 'count')]
244
223
    takes_args = [ "location?" ]
245
224
    aliases = [ "visualize", "vis", "viz" ]
248
227
        set_ui_factory()
249
228
        (br, path) = branch.Branch.open_containing(location)
250
229
        br.lock_read()
 
230
        br.repository.lock_read()
251
231
        try:
252
232
            if revision is None:
253
233
                revid = br.last_revision()
256
236
            else:
257
237
                (revno, revid) = revision[0].in_history(br)
258
238
 
 
239
            from viz.branchwin import BranchWindow
259
240
            import gtk
260
 
            pp = start_viz_window(br, revid, limit)
 
241
                
 
242
            pp = BranchWindow()
 
243
            pp.set_branch(br, revid, limit)
261
244
            pp.connect("destroy", lambda w: gtk.main_quit())
262
245
            pp.show()
263
246
            gtk.main()
264
247
        finally:
 
248
            br.repository.unlock()
265
249
            br.unlock()
266
250
 
267
251
 
268
 
class cmd_gannotate(GTKCommand):
 
252
register_command(cmd_visualise)
 
253
 
 
254
class cmd_gannotate(Command):
269
255
    """GTK+ annotate.
270
256
    
271
257
    Browse changes to FILENAME line by line in a GTK+ window.
273
259
 
274
260
    takes_args = ["filename", "line?"]
275
261
    takes_options = [
276
 
        Option("all", help="Show annotations on all lines."),
277
 
        Option("plain", help="Don't highlight annotation lines."),
 
262
        Option("all", help="show annotations on all lines"),
 
263
        Option("plain", help="don't highlight annotation lines"),
278
264
        Option("line", type=int, argname="lineno",
279
 
               help="Jump to specified line number."),
 
265
               help="jump to specified line number"),
280
266
        "revision",
281
267
    ]
282
268
    aliases = ["gblame", "gpraise"]
283
269
    
284
270
    def run(self, filename, all=False, plain=False, line='1', revision=None):
285
 
        gtk = self.open_display()
 
271
        pygtk = import_pygtk()
 
272
 
 
273
        try:
 
274
            import gtk
 
275
        except RuntimeError, e:
 
276
            if str(e) == "could not open display":
 
277
                raise NoDisplayError
 
278
        set_ui_factory()
286
279
 
287
280
        try:
288
281
            line = int(line)
292
285
 
293
286
        from annotate.gannotate import GAnnotateWindow
294
287
        from annotate.config import GAnnotateConfig
295
 
        from bzrlib.bzrdir import BzrDir
296
288
 
297
289
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
298
290
        if wt is not None:
329
321
            if wt is not None:
330
322
                wt.unlock()
331
323
 
332
 
 
333
 
 
334
 
class cmd_gcommit(GTKCommand):
 
324
register_command(cmd_gannotate)
 
325
 
 
326
class cmd_gcommit(Command):
335
327
    """GTK+ commit dialog
336
328
 
337
329
    Graphical user interface for committing revisions"""
342
334
 
343
335
    def run(self, filename=None):
344
336
        import os
345
 
        self.open_display()
 
337
        pygtk = import_pygtk()
 
338
 
 
339
        try:
 
340
            import gtk
 
341
        except RuntimeError, e:
 
342
            if str(e) == "could not open display":
 
343
                raise NoDisplayError
 
344
 
 
345
        set_ui_factory()
346
346
        from commit import CommitDialog
 
347
        from bzrlib.commit import Commit
347
348
        from bzrlib.errors import (BzrCommandError,
348
349
                                   NotBranchError,
349
 
                                   NoWorkingTree)
 
350
                                   NoWorkingTree,
 
351
                                   PointlessCommit,
 
352
                                   ConflictsInTree,
 
353
                                   StrictCommitFailed)
350
354
 
351
355
        wt = None
352
356
        br = None
353
357
        try:
354
358
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
355
359
            br = wt.branch
 
360
        except NotBranchError, e:
 
361
            path = e.path
356
362
        except NoWorkingTree, e:
357
363
            path = e.base
358
 
            (br, path) = branch.Branch.open_containing(path)
 
364
            try:
 
365
                (br, path) = branch.Branch.open_containing(path)
 
366
            except NotBranchError, e:
 
367
                path = e.path
 
368
 
359
369
 
360
370
        commit = CommitDialog(wt, path, not br)
361
371
        commit.run()
362
372
 
363
 
 
364
 
 
365
 
class cmd_gstatus(GTKCommand):
 
373
register_command(cmd_gcommit)
 
374
 
 
375
class cmd_gstatus(Command):
366
376
    """GTK+ status dialog
367
377
 
368
378
    Graphical user interface for showing status 
374
384
 
375
385
    def run(self, path='.'):
376
386
        import os
377
 
        gtk = self.open_display()
 
387
        pygtk = import_pygtk()
 
388
 
 
389
        try:
 
390
            import gtk
 
391
        except RuntimeError, e:
 
392
            if str(e) == "could not open display":
 
393
                raise NoDisplayError
 
394
 
 
395
        set_ui_factory()
378
396
        from status import StatusDialog
379
397
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
380
398
        status = StatusDialog(wt, wt_path)
381
399
        status.connect("destroy", gtk.main_quit)
382
400
        status.run()
383
401
 
384
 
 
385
 
 
386
 
class cmd_gconflicts(GTKCommand):
 
402
register_command(cmd_gstatus)
 
403
 
 
404
class cmd_gconflicts(Command):
387
405
    """ GTK+ push.
388
406
    
389
407
    """
390
408
    def run(self):
391
409
        (wt, path) = workingtree.WorkingTree.open_containing('.')
392
 
        self.open_display()
 
410
        
 
411
        pygtk = import_pygtk()
 
412
        try:
 
413
            import gtk
 
414
        except RuntimeError, e:
 
415
            if str(e) == "could not open display":
 
416
                raise NoDisplayError
 
417
 
393
418
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
 
419
 
 
420
        set_ui_factory()
394
421
        dialog = ConflictsDialog(wt)
395
422
        dialog.run()
396
423
 
397
 
 
398
 
 
399
 
class cmd_gpreferences(GTKCommand):
400
 
    """ GTK+ preferences dialog.
401
 
 
402
 
    """
403
 
    def run(self):
404
 
        self.open_display()
405
 
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
406
 
        dialog = PreferencesWindow()
407
 
        dialog.run()
408
 
 
409
 
 
410
 
 
411
 
class cmd_gmissing(Command):
412
 
    """ GTK+ missing revisions dialog.
413
 
 
414
 
    """
415
 
    takes_args = ["other_branch?"]
416
 
    def run(self, other_branch=None):
417
 
        pygtk = import_pygtk()
418
 
        try:
419
 
            import gtk
420
 
        except RuntimeError, e:
421
 
            if str(e) == "could not open display":
422
 
                raise NoDisplayError
423
 
 
424
 
        from bzrlib.plugins.gtk.missing import MissingWindow
425
 
        from bzrlib.branch import Branch
426
 
 
427
 
        local_branch = Branch.open_containing(".")[0]
428
 
        if other_branch is None:
429
 
            other_branch = local_branch.get_parent()
430
 
            
431
 
            if other_branch is None:
432
 
                raise errors.BzrCommandError("No peer location known or specified.")
433
 
        remote_branch = Branch.open_containing(other_branch)[0]
434
 
        set_ui_factory()
435
 
        local_branch.lock_read()
436
 
        try:
437
 
            remote_branch.lock_read()
438
 
            try:
439
 
                dialog = MissingWindow(local_branch, remote_branch)
440
 
                dialog.run()
441
 
            finally:
442
 
                remote_branch.unlock()
443
 
        finally:
444
 
            local_branch.unlock()
445
 
 
446
 
 
447
 
class cmd_ginit(GTKCommand):
448
 
    def run(self):
449
 
        self.open_display()
450
 
        from initialize import InitDialog
451
 
        dialog = InitDialog(os.path.abspath(os.path.curdir))
452
 
        dialog.run()
453
 
 
454
 
 
455
 
class cmd_gtags(GTKCommand):
456
 
    def run(self):
457
 
        br = branch.Branch.open_containing('.')[0]
458
 
        
459
 
        gtk = self.open_display()
460
 
        from tags import TagsWindow
461
 
        window = TagsWindow(br)
462
 
        window.show()
463
 
        gtk.main()
464
 
 
465
 
 
466
 
commands = [
467
 
    cmd_gmissing, 
468
 
    cmd_gpreferences, 
469
 
    cmd_gconflicts, 
470
 
    cmd_gstatus,
471
 
    cmd_gcommit, 
472
 
    cmd_gannotate, 
473
 
    cmd_visualise, 
474
 
    cmd_gdiff,
475
 
    cmd_gpush, 
476
 
    cmd_gcheckout, 
477
 
    cmd_gbranch,
478
 
    cmd_ginit,
479
 
    cmd_gtags
480
 
    ]
481
 
 
482
 
for cmd in commands:
483
 
    register_command(cmd)
484
 
 
485
 
 
486
 
class cmd_commit_notify(GTKCommand):
487
 
    """Run the bzr commit notifier.
488
 
 
489
 
    This is a background program which will pop up a notification on the users
490
 
    screen when a commit occurs.
491
 
    """
492
 
 
493
 
    def run(self):
494
 
        from notify import NotifyPopupMenu
495
 
        gtk = self.open_display()
496
 
        menu = NotifyPopupMenu()
497
 
        icon = gtk.status_icon_new_from_file(os.path.join(data_path(), "bzr-icon-64.png"))
498
 
        icon.connect('popup-menu', menu.display)
499
 
 
500
 
        import cgi
501
 
        import dbus
502
 
        import dbus.service
503
 
        import pynotify
504
 
        from bzrlib.bzrdir import BzrDir
505
 
        from bzrlib import errors
506
 
        from bzrlib.osutils import format_date
507
 
        from bzrlib.transport import get_transport
508
 
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
509
 
            import dbus.glib
510
 
        from bzrlib.plugins.dbus import activity
511
 
        bus = dbus.SessionBus()
512
 
        # get the object so we can subscribe to callbacks from it.
513
 
        broadcast_service = bus.get_object(
514
 
            activity.Broadcast.DBUS_NAME,
515
 
            activity.Broadcast.DBUS_PATH)
516
 
 
517
 
        def catch_branch(revision_id, urls):
518
 
            # TODO: show all the urls, or perhaps choose the 'best'.
519
 
            url = urls[0]
520
 
            try:
521
 
                if isinstance(revision_id, unicode):
522
 
                    revision_id = revision_id.encode('utf8')
523
 
                transport = get_transport(url)
524
 
                a_dir = BzrDir.open_from_transport(transport)
525
 
                branch = a_dir.open_branch()
526
 
                revno = branch.revision_id_to_revno(revision_id)
527
 
                revision = branch.repository.get_revision(revision_id)
528
 
                summary = 'New revision %d in %s' % (revno, url)
529
 
                body  = 'Committer: %s\n' % revision.committer
530
 
                body += 'Date: %s\n' % format_date(revision.timestamp,
531
 
                    revision.timezone)
532
 
                body += '\n'
533
 
                body += revision.message
534
 
                body = cgi.escape(body)
535
 
                nw = pynotify.Notification(summary, body)
536
 
                def start_viz(notification=None, action=None, data=None):
537
 
                    """Start the viz program."""
538
 
                    pp = start_viz_window(branch, revision_id)
539
 
                    pp.show()
540
 
                def start_branch(notification=None, action=None, data=None):
541
 
                    """Start a Branch dialog"""
542
 
                    from bzrlib.plugins.gtk.branch import BranchDialog
543
 
                    bd = BranchDialog(remote_path=url)
544
 
                    bd.run()
545
 
                nw.add_action("inspect", "Inspect", start_viz, None)
546
 
                nw.add_action("branch", "Branch", start_branch, None)
547
 
                nw.set_timeout(5000)
548
 
                nw.show()
549
 
            except Exception, e:
550
 
                print e
551
 
                raise
552
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
553
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
554
 
        pynotify.init("bzr commit-notify")
555
 
        gtk.main()
556
 
 
557
 
register_command(cmd_commit_notify)
558
 
 
559
 
 
560
 
class cmd_gselftest(GTKCommand):
561
 
    """Version of selftest that displays a notification at the end"""
562
 
 
563
 
    takes_args = builtins.cmd_selftest.takes_args
564
 
    takes_options = builtins.cmd_selftest.takes_options
565
 
    _see_also = ['selftest']
566
 
 
567
 
    def run(self, *args, **kwargs):
568
 
        import cgi
569
 
        # prevent gtk from blowing up later
570
 
        gtk = import_pygtk()
571
 
        import pynotify
572
 
        result = builtins.cmd_selftest().run(*args, **kwargs)
573
 
        if result == 0:
574
 
            summary = 'Success'
575
 
            body = 'Selftest succeeded in "%s"' % os.getcwd()
576
 
        if result == 1:
577
 
            summary = 'Failure'
578
 
            body = 'Selftest failed in "%s"' % os.getcwd()
579
 
        pynotify.init("bzr gselftest")
580
 
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
581
 
        note.set_timeout(pynotify.EXPIRES_NEVER)
582
 
        note.show()
583
 
 
584
 
 
585
 
register_command(cmd_gselftest)
586
 
 
 
424
register_command(cmd_gconflicts)
587
425
 
588
426
import gettext
589
427
gettext.install('olive-gtk')
590
428
 
591
 
 
592
429
class NoDisplayError(BzrCommandError):
593
430
    """gtk could not find a proper display"""
594
431
 
595
432
    def __str__(self):
596
433
        return "No DISPLAY. Unable to run GTK+ application."
597
434
 
598
 
 
599
435
def test_suite():
600
436
    from unittest import TestSuite
601
437
    import tests
605
441
        result = TestSuite()
606
442
        result.addTest(tests.test_suite())
607
443
    finally:
608
 
        if sys.getdefaultencoding() != default_encoding:
609
 
            reload(sys)
610
 
            sys.setdefaultencoding(default_encoding)
 
444
        reload(sys)
 
445
        sys.setdefaultencoding(default_encoding)
611
446
    return result