/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
  • Date: 2008-06-29 18:12:29 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629181229-1l2m4cf7vvbyh8qg
Simplify progress bar code, use embedded progress bar inside viz window.

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
 
"""GTK+ frontends to Bazaar commands """
 
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+ conflicts. 
 
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
gsend             GTK+ send merge directive.
 
30
gstatus           GTK+ status dialog.
 
31
gtags             Manage branch tags.
 
32
visualise         Graphically visualise this branch. 
 
33
"""
 
34
 
 
35
import sys
16
36
 
17
37
import bzrlib
18
38
 
19
 
__version__ = '0.16.0'
20
 
version_info = tuple(int(n) for n in __version__.split('.'))
21
 
 
 
39
version_info = (0, 95, 0, 'dev', 1)
 
40
 
 
41
if version_info[3] == 'final':
 
42
    version_string = '%d.%d.%d' % version_info[:3]
 
43
else:
 
44
    version_string = '%d.%d.%d%s%d' % version_info
 
45
__version__ = version_string
 
46
 
 
47
required_bzrlib = (1, 3)
22
48
 
23
49
def check_bzrlib_version(desired):
24
50
    """Check that bzrlib is compatible.
25
51
 
26
52
    If version is < bzr-gtk version, assume incompatible.
27
 
    If version == bzr-gtk version, assume completely compatible
28
 
    If version == bzr-gtk version + 1, assume compatible, with deprecations
29
 
    Otherwise, assume incompatible.
30
53
    """
31
 
    desired_plus = (desired[0], desired[1]+1)
32
54
    bzrlib_version = bzrlib.version_info[:2]
33
 
    if bzrlib_version == desired:
34
 
        return
35
55
    try:
36
56
        from bzrlib.trace import warning
37
57
    except ImportError:
38
58
        # get the message out any way we can
39
59
        from warnings import warn as warning
40
60
    if bzrlib_version < desired:
41
 
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
 
61
        from bzrlib.errors import BzrError
 
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
42
63
                ' %s.' % (bzrlib.__version__, __version__))
43
 
        # Not using BzrNewError, because it may not exist.
44
 
        raise Exception, ('Version mismatch', version_info)
45
 
    else:
46
 
        warning('bzr-gtk is not up to date with installed bzr version %s.'
47
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
48
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
49
 
        if bzrlib_version != desired_plus:
50
 
            raise Exception, 'Version mismatch'
51
 
 
52
 
 
53
 
check_bzrlib_version(version_info[:2])
 
64
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
 
65
 
 
66
 
 
67
if version_info[2] == "final":
 
68
    check_bzrlib_version(required_bzrlib)
54
69
 
55
70
from bzrlib.trace import warning
56
71
if __name__ != 'bzrlib.plugins.gtk':
60
75
lazy_import(globals(), """
61
76
from bzrlib import (
62
77
    branch,
 
78
    builtins,
63
79
    errors,
 
80
    merge_directive,
64
81
    workingtree,
65
82
    )
66
83
""")
67
84
 
68
85
from bzrlib.commands import Command, register_command, display_command
69
86
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
70
 
from bzrlib.commands import Command, register_command
71
87
from bzrlib.option import Option
72
 
from bzrlib.bzrdir import BzrDir
73
88
 
74
89
import os.path
75
90
 
83
98
 
84
99
 
85
100
def set_ui_factory():
86
 
    pygtk = import_pygtk()
 
101
    import_pygtk()
87
102
    from ui import GtkUIFactory
88
103
    import bzrlib.ui
89
104
    bzrlib.ui.ui_factory = GtkUIFactory()
90
105
 
91
106
 
92
 
class cmd_gbranch(Command):
 
107
def data_path():
 
108
    return os.path.dirname(__file__)
 
109
 
 
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
class GTKCommand(Command):
 
134
    """Abstract class providing GTK specific run commands."""
 
135
 
 
136
    def run(self):
 
137
        open_display()
 
138
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
 
139
        dialog.run()
 
140
 
 
141
 
 
142
class cmd_gbranch(GTKCommand):
93
143
    """GTK+ branching.
94
144
    
95
145
    """
96
146
 
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
 
 
 
147
    def get_gtk_dialog(self, path):
105
148
        from bzrlib.plugins.gtk.branch import BranchDialog
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):
 
149
        return BranchDialog(path)
 
150
 
 
151
 
 
152
class cmd_gcheckout(GTKCommand):
114
153
    """ GTK+ checkout.
115
154
    
116
155
    """
117
156
    
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
 
 
 
157
    def get_gtk_dialog(self, path):
126
158
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
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):
 
159
        return CheckoutDialog(path)
 
160
 
 
161
 
 
162
 
 
163
class cmd_gpush(GTKCommand):
135
164
    """ GTK+ push.
136
165
    
137
166
    """
139
168
 
140
169
    def run(self, location="."):
141
170
        (br, path) = branch.Branch.open_containing(location)
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
 
 
 
171
        open_display()
150
172
        from push import PushDialog
151
 
 
152
 
        set_ui_factory()
153
 
        dialog = PushDialog(br)
 
173
        dialog = PushDialog(br.repository, br.last_revision(), br)
154
174
        dialog.run()
155
175
 
156
 
register_command(cmd_gpush)
157
 
 
158
 
class cmd_gdiff(Command):
 
176
 
 
177
 
 
178
class cmd_gdiff(GTKCommand):
159
179
    """Show differences in working tree in a GTK+ Window.
160
180
    
161
181
    Otherwise, all changes for the tree are listed.
173
193
            if revision is not None:
174
194
                if len(revision) == 1:
175
195
                    tree1 = wt
176
 
                    revision_id = revision[0].in_history(branch).rev_id
 
196
                    revision_id = revision[0].as_revision_id(tree1.branch)
177
197
                    tree2 = branch.repository.revision_tree(revision_id)
178
198
                elif len(revision) == 2:
179
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
199
                    revision_id_0 = revision[0].as_revision_id(branch)
180
200
                    tree2 = branch.repository.revision_tree(revision_id_0)
181
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
201
                    revision_id_1 = revision[1].as_revision_id(branch)
182
202
                    tree1 = branch.repository.revision_tree(revision_id_1)
183
203
            else:
184
204
                tree1 = wt
194
214
                try:
195
215
                    window.set_file(tree_filename)
196
216
                except NoSuchFile:
197
 
                    if (tree1.inventory.path2id(tree_filename) is None and 
198
 
                        tree2.inventory.path2id(tree_filename) is None):
 
217
                    if (tree1.path2id(tree_filename) is None and 
 
218
                        tree2.path2id(tree_filename) is None):
199
219
                        raise NotVersionedError(filename)
200
220
                    raise BzrCommandError('No changes found for file "%s"' % 
201
221
                                          filename)
205
225
        finally:
206
226
            wt.unlock()
207
227
 
208
 
register_command(cmd_gdiff)
 
228
 
 
229
def start_viz_window(branch, revisions, limit=None):
 
230
    """Start viz on branch with revision revision.
 
231
    
 
232
    :return: The viz window object.
 
233
    """
 
234
    from viz import BranchWindow
 
235
    return BranchWindow(branch, revisions, limit)
 
236
 
209
237
 
210
238
class cmd_visualise(Command):
211
239
    """Graphically visualise this branch.
218
246
    """
219
247
    takes_options = [
220
248
        "revision",
221
 
        Option('limit', "maximum number of revisions to display",
 
249
        Option('limit', "Maximum number of revisions to display.",
222
250
               int, 'count')]
223
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
224
252
    aliases = [ "visualize", "vis", "viz" ]
225
253
 
226
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
227
255
        set_ui_factory()
228
 
        (br, path) = branch.Branch.open_containing(location)
229
 
        br.lock_read()
230
 
        br.repository.lock_read()
231
 
        try:
 
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)
232
261
            if revision is None:
233
 
                revid = br.last_revision()
234
 
                if revid is None:
235
 
                    return
 
262
                revids.append(br.last_revision())
236
263
            else:
237
 
                (revno, revid) = revision[0].in_history(br)
238
 
 
239
 
            from viz.branchwin import BranchWindow
240
 
            import gtk
241
 
                
242
 
            pp = BranchWindow()
243
 
            pp.set_branch(br, revid, limit)
244
 
            pp.connect("destroy", lambda w: gtk.main_quit())
245
 
            pp.show()
246
 
            gtk.main()
247
 
        finally:
248
 
            br.repository.unlock()
249
 
            br.unlock()
250
 
 
251
 
 
252
 
register_command(cmd_visualise)
253
 
 
254
 
class cmd_gannotate(Command):
 
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()
 
270
 
 
271
 
 
272
class cmd_gannotate(GTKCommand):
255
273
    """GTK+ annotate.
256
274
    
257
275
    Browse changes to FILENAME line by line in a GTK+ window.
259
277
 
260
278
    takes_args = ["filename", "line?"]
261
279
    takes_options = [
262
 
        Option("all", help="show annotations on all lines"),
263
 
        Option("plain", help="don't highlight annotation lines"),
 
280
        Option("all", help="Show annotations on all lines."),
 
281
        Option("plain", help="Don't highlight annotation lines."),
264
282
        Option("line", type=int, argname="lineno",
265
 
               help="jump to specified line number"),
 
283
               help="Jump to specified line number."),
266
284
        "revision",
267
285
    ]
268
286
    aliases = ["gblame", "gpraise"]
269
287
    
270
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
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()
 
289
        gtk = open_display()
279
290
 
280
291
        try:
281
292
            line = int(line)
285
296
 
286
297
        from annotate.gannotate import GAnnotateWindow
287
298
        from annotate.config import GAnnotateConfig
 
299
        from bzrlib.bzrdir import BzrDir
288
300
 
289
301
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
290
302
        if wt is not None:
299
311
        if revision is not None:
300
312
            if len(revision) != 1:
301
313
                raise BzrCommandError("Only 1 revion may be specified.")
302
 
            revision_id = revision[0].in_history(br).rev_id
 
314
            revision_id = revision[0].as_revision_id(br)
303
315
            tree = br.repository.revision_tree(revision_id)
304
316
        else:
305
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
306
318
 
307
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
308
320
        window.connect("destroy", lambda w: gtk.main_quit())
309
 
        window.set_title(path + " - gannotate")
310
321
        config = GAnnotateConfig(window)
311
322
        window.show()
312
323
        br.lock_read()
321
332
            if wt is not None:
322
333
                wt.unlock()
323
334
 
324
 
register_command(cmd_gannotate)
325
 
 
326
 
class cmd_gcommit(Command):
 
335
 
 
336
 
 
337
class cmd_gcommit(GTKCommand):
327
338
    """GTK+ commit dialog
328
339
 
329
340
    Graphical user interface for committing revisions"""
330
 
    
 
341
 
331
342
    aliases = [ "gci" ]
332
343
    takes_args = []
333
344
    takes_options = []
334
345
 
335
346
    def run(self, filename=None):
336
347
        import os
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()
 
348
        open_display()
346
349
        from commit import CommitDialog
347
 
        from bzrlib.commit import Commit
348
350
        from bzrlib.errors import (BzrCommandError,
349
351
                                   NotBranchError,
350
 
                                   NoWorkingTree,
351
 
                                   PointlessCommit,
352
 
                                   ConflictsInTree,
353
 
                                   StrictCommitFailed)
 
352
                                   NoWorkingTree)
354
353
 
355
354
        wt = None
356
355
        br = None
357
356
        try:
358
357
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
359
358
            br = wt.branch
360
 
        except NotBranchError, e:
361
 
            path = e.path
362
359
        except NoWorkingTree, e:
363
 
            path = e.base
364
 
            try:
365
 
                (br, path) = branch.Branch.open_containing(path)
366
 
            except NotBranchError, e:
367
 
                path = e.path
368
 
 
369
 
 
370
 
        commit = CommitDialog(wt, path, not br)
371
 
        commit.run()
372
 
 
373
 
register_command(cmd_gcommit)
374
 
 
375
 
class cmd_gstatus(Command):
 
360
            from dialog import error_dialog
 
361
            error_dialog(_i18n('Directory does not have a working tree'),
 
362
                         _i18n('Operation aborted.'))
 
363
            return 1 # should this be retval=3?
 
364
 
 
365
        # It is a good habit to keep things locked for the duration, but it
 
366
        # could cause difficulties if someone wants to do things in another
 
367
        # window... We could lock_read() until we actually go to commit
 
368
        # changes... Just a thought.
 
369
        wt.lock_write()
 
370
        try:
 
371
            dlg = CommitDialog(wt)
 
372
            return dlg.run()
 
373
        finally:
 
374
            wt.unlock()
 
375
 
 
376
 
 
377
class cmd_gstatus(GTKCommand):
376
378
    """GTK+ status dialog
377
379
 
378
380
    Graphical user interface for showing status 
380
382
    
381
383
    aliases = [ "gst" ]
382
384
    takes_args = ['PATH?']
383
 
    takes_options = []
 
385
    takes_options = ['revision']
384
386
 
385
 
    def run(self, path='.'):
 
387
    def run(self, path='.', revision=None):
386
388
        import os
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()
 
389
        gtk = open_display()
396
390
        from status import StatusDialog
397
391
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
398
 
        status = StatusDialog(wt, wt_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)
399
403
        status.connect("destroy", gtk.main_quit)
400
404
        status.run()
401
405
 
402
 
register_command(cmd_gstatus)
403
 
 
404
 
class cmd_gconflicts(Command):
405
 
    """ GTK+ push.
 
406
 
 
407
class cmd_gsend(GTKCommand):
 
408
    """GTK+ send merge directive.
 
409
 
 
410
    """
 
411
    def run(self):
 
412
        (br, path) = branch.Branch.open_containing(".")
 
413
        gtk = open_display()
 
414
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
415
        from StringIO import StringIO
 
416
        dialog = SendMergeDirectiveDialog(br)
 
417
        if dialog.run() == gtk.RESPONSE_OK:
 
418
            outf = StringIO()
 
419
            outf.writelines(dialog.get_merge_directive().to_lines())
 
420
            mail_client = br.get_config().get_mail_client()
 
421
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
422
                outf.getvalue())
 
423
 
 
424
            
 
425
 
 
426
 
 
427
class cmd_gconflicts(GTKCommand):
 
428
    """GTK+ conflicts.
406
429
    
 
430
    Select files from the list of conflicts and run an external utility to
 
431
    resolve them.
407
432
    """
408
433
    def run(self):
409
434
        (wt, path) = workingtree.WorkingTree.open_containing('.')
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
 
 
 
435
        open_display()
418
436
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
419
 
 
420
 
        set_ui_factory()
421
437
        dialog = ConflictsDialog(wt)
422
438
        dialog.run()
423
439
 
424
 
register_command(cmd_gconflicts)
 
440
 
 
441
class cmd_gpreferences(GTKCommand):
 
442
    """ GTK+ preferences dialog.
 
443
 
 
444
    """
 
445
    def run(self):
 
446
        open_display()
 
447
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
 
448
        dialog = PreferencesWindow()
 
449
        dialog.run()
 
450
 
 
451
 
 
452
class cmd_gmissing(Command):
 
453
    """ GTK+ missing revisions dialog.
 
454
 
 
455
    """
 
456
    takes_args = ["other_branch?"]
 
457
    def run(self, other_branch=None):
 
458
        pygtk = import_pygtk()
 
459
        try:
 
460
            import gtk
 
461
        except RuntimeError, e:
 
462
            if str(e) == "could not open display":
 
463
                raise NoDisplayError
 
464
 
 
465
        from bzrlib.plugins.gtk.missing import MissingWindow
 
466
        from bzrlib.branch import Branch
 
467
 
 
468
        local_branch = Branch.open_containing(".")[0]
 
469
        if other_branch is None:
 
470
            other_branch = local_branch.get_parent()
 
471
            
 
472
            if other_branch is None:
 
473
                raise errors.BzrCommandError("No peer location known or specified.")
 
474
        remote_branch = Branch.open_containing(other_branch)[0]
 
475
        set_ui_factory()
 
476
        local_branch.lock_read()
 
477
        try:
 
478
            remote_branch.lock_read()
 
479
            try:
 
480
                dialog = MissingWindow(local_branch, remote_branch)
 
481
                dialog.run()
 
482
            finally:
 
483
                remote_branch.unlock()
 
484
        finally:
 
485
            local_branch.unlock()
 
486
 
 
487
 
 
488
class cmd_ginit(GTKCommand):
 
489
    def run(self):
 
490
        open_display()
 
491
        from initialize import InitDialog
 
492
        dialog = InitDialog(os.path.abspath(os.path.curdir))
 
493
        dialog.run()
 
494
 
 
495
 
 
496
class cmd_gtags(GTKCommand):
 
497
    def run(self):
 
498
        br = branch.Branch.open_containing('.')[0]
 
499
        
 
500
        gtk = open_display()
 
501
        from tags import TagsWindow
 
502
        window = TagsWindow(br)
 
503
        window.show()
 
504
        gtk.main()
 
505
 
 
506
 
 
507
commands = [
 
508
    cmd_gannotate, 
 
509
    cmd_gbranch,
 
510
    cmd_gcheckout, 
 
511
    cmd_gcommit, 
 
512
    cmd_gconflicts, 
 
513
    cmd_gdiff,
 
514
    cmd_ginit,
 
515
    cmd_gmissing, 
 
516
    cmd_gpreferences, 
 
517
    cmd_gpush, 
 
518
    cmd_gsend,
 
519
    cmd_gstatus,
 
520
    cmd_gtags,
 
521
    cmd_visualise
 
522
    ]
 
523
 
 
524
for cmd in commands:
 
525
    register_command(cmd)
 
526
 
 
527
 
 
528
class cmd_commit_notify(GTKCommand):
 
529
    """Run the bzr commit notifier.
 
530
 
 
531
    This is a background program which will pop up a notification on the users
 
532
    screen when a commit occurs.
 
533
    """
 
534
 
 
535
    def run(self):
 
536
        from notify import NotifyPopupMenu
 
537
        gtk = open_display()
 
538
        menu = NotifyPopupMenu()
 
539
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
 
540
        icon.connect('popup-menu', menu.display)
 
541
 
 
542
        import cgi
 
543
        import dbus
 
544
        import dbus.service
 
545
        import pynotify
 
546
        from bzrlib.bzrdir import BzrDir
 
547
        from bzrlib import errors
 
548
        from bzrlib.osutils import format_date
 
549
        from bzrlib.transport import get_transport
 
550
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
 
551
            import dbus.glib
 
552
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
 
553
        bus = dbus.SessionBus()
 
554
 
 
555
        def catch_branch(revision_id, urls):
 
556
            # TODO: show all the urls, or perhaps choose the 'best'.
 
557
            url = urls[0]
 
558
            try:
 
559
                if isinstance(revision_id, unicode):
 
560
                    revision_id = revision_id.encode('utf8')
 
561
                transport = get_transport(url)
 
562
                a_dir = BzrDir.open_from_transport(transport)
 
563
                branch = a_dir.open_branch()
 
564
                revno = branch.revision_id_to_revno(revision_id)
 
565
                revision = branch.repository.get_revision(revision_id)
 
566
                summary = 'New revision %d in %s' % (revno, url)
 
567
                body  = 'Committer: %s\n' % revision.committer
 
568
                body += 'Date: %s\n' % format_date(revision.timestamp,
 
569
                    revision.timezone)
 
570
                body += '\n'
 
571
                body += revision.message
 
572
                body = cgi.escape(body)
 
573
                nw = pynotify.Notification(summary, body)
 
574
                def start_viz(notification=None, action=None, data=None):
 
575
                    """Start the viz program."""
 
576
                    pp = start_viz_window(branch, revision_id)
 
577
                    pp.show()
 
578
                def start_branch(notification=None, action=None, data=None):
 
579
                    """Start a Branch dialog"""
 
580
                    from bzrlib.plugins.gtk.branch import BranchDialog
 
581
                    bd = BranchDialog(remote_path=url)
 
582
                    bd.run()
 
583
                nw.add_action("inspect", "Inspect", start_viz, None)
 
584
                nw.add_action("branch", "Branch", start_branch, None)
 
585
                nw.set_timeout(5000)
 
586
                nw.show()
 
587
            except Exception, e:
 
588
                print e
 
589
                raise
 
590
        bus.add_signal_receiver(catch_branch,
 
591
                                dbus_interface=BROADCAST_INTERFACE,
 
592
                                signal_name="Revision")
 
593
        pynotify.init("bzr commit-notify")
 
594
        gtk.main()
 
595
 
 
596
register_command(cmd_commit_notify)
 
597
 
 
598
 
 
599
class cmd_gselftest(GTKCommand):
 
600
    """Version of selftest that displays a notification at the end"""
 
601
 
 
602
    takes_args = builtins.cmd_selftest.takes_args
 
603
    takes_options = builtins.cmd_selftest.takes_options
 
604
    _see_also = ['selftest']
 
605
 
 
606
    def run(self, *args, **kwargs):
 
607
        import cgi
 
608
        import sys
 
609
        default_encoding = sys.getdefaultencoding()
 
610
        # prevent gtk from blowing up later
 
611
        gtk = import_pygtk()
 
612
        # prevent gtk from messing with default encoding
 
613
        import pynotify
 
614
        if sys.getdefaultencoding() != default_encoding:
 
615
            reload(sys)
 
616
            sys.setdefaultencoding(default_encoding)
 
617
        result = builtins.cmd_selftest().run(*args, **kwargs)
 
618
        if result == 0:
 
619
            summary = 'Success'
 
620
            body = 'Selftest succeeded in "%s"' % os.getcwd()
 
621
        if result == 1:
 
622
            summary = 'Failure'
 
623
            body = 'Selftest failed in "%s"' % os.getcwd()
 
624
        pynotify.init("bzr gselftest")
 
625
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
 
626
        note.set_timeout(pynotify.EXPIRES_NEVER)
 
627
        note.show()
 
628
 
 
629
 
 
630
register_command(cmd_gselftest)
 
631
 
 
632
 
 
633
class cmd_test_gtk(GTKCommand):
 
634
    """Version of selftest that just runs the gtk test suite."""
 
635
 
 
636
    takes_options = ['verbose',
 
637
                     Option('one', short_name='1',
 
638
                            help='Stop when one test fails.'),
 
639
                     Option('benchmark', help='Run the benchmarks.'),
 
640
                     Option('lsprof-timed',
 
641
                     help='Generate lsprof output for benchmarked'
 
642
                          ' sections of code.'),
 
643
                     Option('list-only',
 
644
                     help='List the tests instead of running them.'),
 
645
                     Option('randomize', type=str, argname="SEED",
 
646
                     help='Randomize the order of tests using the given'
 
647
                          ' seed or "now" for the current time.'),
 
648
                    ]
 
649
    takes_args = ['testspecs*']
 
650
 
 
651
    def run(self, verbose=None, one=False, benchmark=None,
 
652
            lsprof_timed=None, list_only=False, randomize=None,
 
653
            testspecs_list=None):
 
654
        from bzrlib import __path__ as bzrlib_path
 
655
        from bzrlib.tests import selftest
 
656
 
 
657
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
658
        if benchmark:
 
659
            print 'No benchmarks yet'
 
660
            return 3
 
661
 
 
662
            test_suite_factory = bench_suite
 
663
            if verbose is None:
 
664
                verbose = True
 
665
            # TODO: should possibly lock the history file...
 
666
            benchfile = open(".perf_history", "at", buffering=1)
 
667
        else:
 
668
            test_suite_factory = test_suite
 
669
            if verbose is None:
 
670
                verbose = False
 
671
            benchfile = None
 
672
 
 
673
        if testspecs_list is not None:
 
674
            pattern = '|'.join(testspecs_list)
 
675
        else:
 
676
            pattern = ".*"
 
677
 
 
678
        try:
 
679
            result = selftest(verbose=verbose,
 
680
                              pattern=pattern,
 
681
                              stop_on_failure=one,
 
682
                              test_suite_factory=test_suite_factory,
 
683
                              lsprof_timed=lsprof_timed,
 
684
                              bench_history=benchfile,
 
685
                              list_only=list_only,
 
686
                              random_seed=randomize,
 
687
                             )
 
688
        finally:
 
689
            if benchfile is not None:
 
690
                benchfile.close()
 
691
 
 
692
register_command(cmd_test_gtk)
 
693
 
 
694
 
425
695
 
426
696
import gettext
427
697
gettext.install('olive-gtk')
428
698
 
 
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
 
429
703
class NoDisplayError(BzrCommandError):
430
704
    """gtk could not find a proper display"""
431
705
 
432
706
    def __str__(self):
433
707
        return "No DISPLAY. Unable to run GTK+ application."
434
708
 
 
709
 
435
710
def test_suite():
436
711
    from unittest import TestSuite
437
712
    import tests
439
714
    default_encoding = sys.getdefaultencoding()
440
715
    try:
441
716
        result = TestSuite()
 
717
        try:
 
718
            import_pygtk()
 
719
        except errors.BzrCommandError:
 
720
            return result
442
721
        result.addTest(tests.test_suite())
443
722
    finally:
444
 
        reload(sys)
445
 
        sys.setdefaultencoding(default_encoding)
 
723
        if sys.getdefaultencoding() != default_encoding:
 
724
            reload(sys)
 
725
            sys.setdefaultencoding(default_encoding)
446
726
    return result