/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 16:24:24 UTC
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629162424-48a6rrjmmpejfcyr
Stop emitting no longer used revisions-loaded message.

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 """
16
 
 
17
 
from bzrlib import errors
 
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
 
36
 
 
37
import bzrlib
 
38
 
 
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)
 
48
 
 
49
def check_bzrlib_version(desired):
 
50
    """Check that bzrlib is compatible.
 
51
 
 
52
    If version is < bzr-gtk version, assume incompatible.
 
53
    """
 
54
    bzrlib_version = bzrlib.version_info[:2]
 
55
    try:
 
56
        from bzrlib.trace import warning
 
57
    except ImportError:
 
58
        # get the message out any way we can
 
59
        from warnings import warn as warning
 
60
    if bzrlib_version < desired:
 
61
        from bzrlib.errors import BzrError
 
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
 
63
                ' %s.' % (bzrlib.__version__, __version__))
 
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)
 
69
 
 
70
from bzrlib.trace import warning
 
71
if __name__ != 'bzrlib.plugins.gtk':
 
72
    warning("Not running as bzrlib.plugins.gtk, things may break.")
 
73
 
 
74
from bzrlib.lazy_import import lazy_import
 
75
lazy_import(globals(), """
 
76
from bzrlib import (
 
77
    branch,
 
78
    builtins,
 
79
    errors,
 
80
    merge_directive,
 
81
    workingtree,
 
82
    )
 
83
""")
 
84
 
18
85
from bzrlib.commands import Command, register_command, display_command
19
86
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
20
 
from bzrlib.commands import Command, register_command
21
87
from bzrlib.option import Option
22
 
from bzrlib.branch import Branch
23
 
from bzrlib.workingtree import WorkingTree
24
 
from bzrlib.bzrdir import BzrDir
25
88
 
26
89
import os.path
27
90
 
28
 
__version__ = '0.13.0'
29
 
 
30
 
 
31
91
def import_pygtk():
32
92
    try:
33
93
        import pygtk
38
98
 
39
99
 
40
100
def set_ui_factory():
41
 
    pygtk = import_pygtk()
42
 
    from olive.ui import GtkUIFactory
 
101
    import_pygtk()
 
102
    from ui import GtkUIFactory
43
103
    import bzrlib.ui
44
104
    bzrlib.ui.ui_factory = GtkUIFactory()
45
105
 
46
106
 
47
 
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):
48
143
    """GTK+ branching.
49
144
    
50
145
    """
51
146
 
52
 
    def run(self):
53
 
        pygtk = import_pygtk()
54
 
        try:
55
 
            import gtk
56
 
        except RuntimeError, e:
57
 
            if str(e) == "could not open display":
58
 
                raise NoDisplayError
59
 
 
60
 
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
61
 
 
62
 
        set_ui_factory()
63
 
        dialog = BranchDialog(os.path.abspath('.'))
64
 
        dialog.window.connect("destroy", lambda w: gtk.main_quit())
65
 
        dialog.display()
66
 
        
67
 
        gtk.main()
68
 
 
69
 
register_command(cmd_gbranch)
70
 
 
71
 
class cmd_gdiff(Command):
 
147
    def get_gtk_dialog(self, path):
 
148
        from bzrlib.plugins.gtk.branch import BranchDialog
 
149
        return BranchDialog(path)
 
150
 
 
151
 
 
152
class cmd_gcheckout(GTKCommand):
 
153
    """ GTK+ checkout.
 
154
    
 
155
    """
 
156
    
 
157
    def get_gtk_dialog(self, path):
 
158
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
 
159
        return CheckoutDialog(path)
 
160
 
 
161
 
 
162
 
 
163
class cmd_gpush(GTKCommand):
 
164
    """ GTK+ push.
 
165
    
 
166
    """
 
167
    takes_args = [ "location?" ]
 
168
 
 
169
    def run(self, location="."):
 
170
        (br, path) = branch.Branch.open_containing(location)
 
171
        open_display()
 
172
        from push import PushDialog
 
173
        dialog = PushDialog(br.repository, br.last_revision(), br)
 
174
        dialog.run()
 
175
 
 
176
 
 
177
 
 
178
class cmd_gdiff(GTKCommand):
72
179
    """Show differences in working tree in a GTK+ Window.
73
180
    
74
181
    Otherwise, all changes for the tree are listed.
79
186
    @display_command
80
187
    def run(self, revision=None, filename=None):
81
188
        set_ui_factory()
82
 
        wt = WorkingTree.open_containing(".")[0]
83
 
        branch = wt.branch
84
 
        if revision is not None:
85
 
            if len(revision) == 1:
 
189
        wt = workingtree.WorkingTree.open_containing(".")[0]
 
190
        wt.lock_read()
 
191
        try:
 
192
            branch = wt.branch
 
193
            if revision is not None:
 
194
                if len(revision) == 1:
 
195
                    tree1 = wt
 
196
                    revision_id = revision[0].as_revision_id(tree1.branch)
 
197
                    tree2 = branch.repository.revision_tree(revision_id)
 
198
                elif len(revision) == 2:
 
199
                    revision_id_0 = revision[0].as_revision_id(branch)
 
200
                    tree2 = branch.repository.revision_tree(revision_id_0)
 
201
                    revision_id_1 = revision[1].as_revision_id(branch)
 
202
                    tree1 = branch.repository.revision_tree(revision_id_1)
 
203
            else:
86
204
                tree1 = wt
87
 
                revision_id = revision[0].in_history(branch).rev_id
88
 
                tree2 = branch.repository.revision_tree(revision_id)
89
 
            elif len(revision) == 2:
90
 
                revision_id_0 = revision[0].in_history(branch).rev_id
91
 
                tree2 = branch.repository.revision_tree(revision_id_0)
92
 
                revision_id_1 = revision[1].in_history(branch).rev_id
93
 
                tree1 = branch.repository.revision_tree(revision_id_1)
94
 
        else:
95
 
            tree1 = wt
96
 
            tree2 = tree1.basis_tree()
97
 
 
98
 
        from viz.diffwin import DiffWindow
99
 
        import gtk
100
 
        window = DiffWindow()
101
 
        window.connect("destroy", lambda w: gtk.main_quit())
102
 
        window.set_diff("Working Tree", tree1, tree2)
103
 
        if filename is not None:
104
 
            tree_filename = wt.relpath(filename)
105
 
            try:
106
 
                window.set_file(tree_filename)
107
 
            except NoSuchFile:
108
 
                if (tree1.inventory.path2id(tree_filename) is None and 
109
 
                    tree2.inventory.path2id(tree_filename) is None):
110
 
                    raise NotVersionedError(filename)
111
 
                raise BzrCommandError('No changes found for file "%s"' % 
112
 
                                      filename)
113
 
        window.show()
114
 
 
115
 
        gtk.main()
116
 
 
117
 
register_command(cmd_gdiff)
 
205
                tree2 = tree1.basis_tree()
 
206
 
 
207
            from diff import DiffWindow
 
208
            import gtk
 
209
            window = DiffWindow()
 
210
            window.connect("destroy", gtk.main_quit)
 
211
            window.set_diff("Working Tree", tree1, tree2)
 
212
            if filename is not None:
 
213
                tree_filename = wt.relpath(filename)
 
214
                try:
 
215
                    window.set_file(tree_filename)
 
216
                except NoSuchFile:
 
217
                    if (tree1.path2id(tree_filename) is None and 
 
218
                        tree2.path2id(tree_filename) is None):
 
219
                        raise NotVersionedError(filename)
 
220
                    raise BzrCommandError('No changes found for file "%s"' % 
 
221
                                          filename)
 
222
            window.show()
 
223
 
 
224
            gtk.main()
 
225
        finally:
 
226
            wt.unlock()
 
227
 
 
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
 
118
237
 
119
238
class cmd_visualise(Command):
120
239
    """Graphically visualise this branch.
127
246
    """
128
247
    takes_options = [
129
248
        "revision",
130
 
        Option('limit', "maximum number of revisions to display",
 
249
        Option('limit', "Maximum number of revisions to display.",
131
250
               int, 'count')]
132
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
133
252
    aliases = [ "visualize", "vis", "viz" ]
134
253
 
135
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
136
255
        set_ui_factory()
137
 
        (branch, path) = Branch.open_containing(location)
138
 
        branch.lock_read()
139
 
        branch.repository.lock_read()
140
 
        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)
141
261
            if revision is None:
142
 
                revid = branch.last_revision()
143
 
                if revid is None:
144
 
                    return
 
262
                revids.append(br.last_revision())
145
263
            else:
146
 
                (revno, revid) = revision[0].in_history(branch)
147
 
 
148
 
            from viz.bzrkapp import BzrkApp
149
 
                
150
 
            app = BzrkApp()
151
 
            app.show(branch, revid, limit)
152
 
        finally:
153
 
            branch.repository.unlock()
154
 
            branch.unlock()
155
 
        app.main()
156
 
 
157
 
 
158
 
register_command(cmd_visualise)
159
 
 
160
 
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):
161
273
    """GTK+ annotate.
162
274
    
163
275
    Browse changes to FILENAME line by line in a GTK+ window.
165
277
 
166
278
    takes_args = ["filename", "line?"]
167
279
    takes_options = [
168
 
        Option("all", help="show annotations on all lines"),
169
 
        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."),
170
282
        Option("line", type=int, argname="lineno",
171
 
               help="jump to specified line number"),
 
283
               help="Jump to specified line number."),
172
284
        "revision",
173
285
    ]
174
286
    aliases = ["gblame", "gpraise"]
175
287
    
176
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
177
 
        pygtk = import_pygtk()
178
 
 
179
 
        try:
180
 
            import gtk
181
 
        except RuntimeError, e:
182
 
            if str(e) == "could not open display":
183
 
                raise NoDisplayError
184
 
        set_ui_factory()
 
289
        gtk = open_display()
185
290
 
186
291
        try:
187
292
            line = int(line)
191
296
 
192
297
        from annotate.gannotate import GAnnotateWindow
193
298
        from annotate.config import GAnnotateConfig
 
299
        from bzrlib.bzrdir import BzrDir
194
300
 
195
 
        try:
196
 
            (tree, path) = WorkingTree.open_containing(filename)
197
 
            branch = tree.branch
198
 
        except errors.NoWorkingTree:
199
 
            (branch, path) = Branch.open_containing(filename)
200
 
            tree = branch.basis_tree()
 
301
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
 
302
        if wt is not None:
 
303
            tree = wt
 
304
        else:
 
305
            tree = br.basis_tree()
201
306
 
202
307
        file_id = tree.path2id(path)
203
308
 
206
311
        if revision is not None:
207
312
            if len(revision) != 1:
208
313
                raise BzrCommandError("Only 1 revion may be specified.")
209
 
            revision_id = revision[0].in_history(branch).rev_id
210
 
            tree = branch.repository.revision_tree(revision_id)
 
314
            revision_id = revision[0].as_revision_id(br)
 
315
            tree = br.repository.revision_tree(revision_id)
211
316
        else:
212
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
213
318
 
214
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
215
320
        window.connect("destroy", lambda w: gtk.main_quit())
216
 
        window.set_title(path + " - gannotate")
217
321
        config = GAnnotateConfig(window)
218
322
        window.show()
219
 
        branch.lock_read()
 
323
        br.lock_read()
 
324
        if wt is not None:
 
325
            wt.lock_read()
220
326
        try:
221
 
            window.annotate(tree, branch, file_id)
 
327
            window.annotate(tree, br, file_id)
 
328
            window.jump_to_line(line)
 
329
            gtk.main()
222
330
        finally:
223
 
            branch.unlock()
224
 
        window.jump_to_line(line)
225
 
        
226
 
        gtk.main()
227
 
 
228
 
register_command(cmd_gannotate)
229
 
 
230
 
class cmd_gcommit(Command):
 
331
            br.unlock()
 
332
            if wt is not None:
 
333
                wt.unlock()
 
334
 
 
335
 
 
336
 
 
337
class cmd_gcommit(GTKCommand):
231
338
    """GTK+ commit dialog
232
339
 
233
340
    Graphical user interface for committing revisions"""
234
 
    
 
341
 
 
342
    aliases = [ "gci" ]
235
343
    takes_args = []
236
344
    takes_options = []
237
345
 
238
346
    def run(self, filename=None):
239
347
        import os
240
 
        pygtk = import_pygtk()
241
 
 
242
 
        try:
243
 
            import gtk
244
 
        except RuntimeError, e:
245
 
            if str(e) == "could not open display":
246
 
                raise NoDisplayError
247
 
 
248
 
        set_ui_factory()
249
 
        from olive.commit import CommitDialog
250
 
        from bzrlib.commit import Commit
 
348
        open_display()
 
349
        from commit import CommitDialog
251
350
        from bzrlib.errors import (BzrCommandError,
252
351
                                   NotBranchError,
253
 
                                   NoWorkingTree,
254
 
                                   PointlessCommit,
255
 
                                   ConflictsInTree,
256
 
                                   StrictCommitFailed)
 
352
                                   NoWorkingTree)
257
353
 
258
354
        wt = None
259
 
        branch = None
 
355
        br = None
260
356
        try:
261
 
            (wt, path) = WorkingTree.open_containing(filename)
262
 
            branch = wt.branch
263
 
        except NotBranchError, e:
264
 
            path = e.path
 
357
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
 
358
            br = wt.branch
265
359
        except NoWorkingTree, e:
266
 
            path = e.base
267
 
            try:
268
 
                (branch, path) = Branch.open_containing(path)
269
 
            except NotBranchError, e:
270
 
                path = e.path
271
 
 
272
 
 
273
 
        commit = CommitDialog(wt, path, not branch)
274
 
        commit.run()
275
 
 
276
 
register_command(cmd_gcommit)
 
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):
 
378
    """GTK+ status dialog
 
379
 
 
380
    Graphical user interface for showing status 
 
381
    information."""
 
382
    
 
383
    aliases = [ "gst" ]
 
384
    takes_args = ['PATH?']
 
385
    takes_options = ['revision']
 
386
 
 
387
    def run(self, path='.', revision=None):
 
388
        import os
 
389
        gtk = open_display()
 
390
        from status import StatusDialog
 
391
        (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)
 
403
        status.connect("destroy", gtk.main_quit)
 
404
        status.run()
 
405
 
 
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.
 
429
    
 
430
    Select files from the list of conflicts and run an external utility to
 
431
    resolve them.
 
432
    """
 
433
    def run(self):
 
434
        (wt, path) = workingtree.WorkingTree.open_containing('.')
 
435
        open_display()
 
436
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
 
437
        dialog = ConflictsDialog(wt)
 
438
        dialog.run()
 
439
 
 
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
 
 
695
 
 
696
import gettext
 
697
gettext.install('olive-gtk')
 
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
277
702
 
278
703
class NoDisplayError(BzrCommandError):
279
704
    """gtk could not find a proper display"""
282
707
        return "No DISPLAY. Unable to run GTK+ application."
283
708
 
284
709
 
 
710
def test_suite():
 
711
    from unittest import TestSuite
 
712
    import tests
 
713
    import sys
 
714
    default_encoding = sys.getdefaultencoding()
 
715
    try:
 
716
        result = TestSuite()
 
717
        try:
 
718
            import_pygtk()
 
719
        except errors.BzrCommandError:
 
720
            return result
 
721
        result.addTest(tests.test_suite())
 
722
    finally:
 
723
        if sys.getdefaultencoding() != default_encoding:
 
724
            reload(sys)
 
725
            sys.setdefaultencoding(default_encoding)
 
726
    return result