/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:11:12 UTC
  • mfrom: (475.2.2 gtk)
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: jelmer@samba.org-20080629161112-3j4zp0r0e7cv6cds
Merge Chad's progress bar in viz patch.

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.15.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])
54
 
 
55
 
from bzrlib import errors
 
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
 
56
85
from bzrlib.commands import Command, register_command, display_command
57
86
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
58
 
from bzrlib.commands import Command, register_command
59
87
from bzrlib.option import Option
60
 
from bzrlib.branch import Branch
61
 
from bzrlib.workingtree import WorkingTree
62
 
from bzrlib.bzrdir import BzrDir
63
88
 
64
89
import os.path
65
90
 
73
98
 
74
99
 
75
100
def set_ui_factory():
76
 
    pygtk = import_pygtk()
77
 
    from olive.ui import GtkUIFactory
 
101
    import_pygtk()
 
102
    from ui import GtkUIFactory
78
103
    import bzrlib.ui
79
104
    bzrlib.ui.ui_factory = GtkUIFactory()
80
105
 
81
106
 
82
 
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):
83
143
    """GTK+ branching.
84
144
    
85
145
    """
86
146
 
87
 
    def run(self):
88
 
        pygtk = import_pygtk()
89
 
        try:
90
 
            import gtk
91
 
        except RuntimeError, e:
92
 
            if str(e) == "could not open display":
93
 
                raise NoDisplayError
94
 
 
95
 
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
96
 
 
97
 
        set_ui_factory()
98
 
        dialog = BranchDialog(os.path.abspath('.'))
99
 
        dialog.window.connect("destroy", lambda w: gtk.main_quit())
100
 
        dialog.display()
101
 
        
102
 
        gtk.main()
103
 
 
104
 
register_command(cmd_gbranch)
105
 
 
106
 
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):
107
179
    """Show differences in working tree in a GTK+ Window.
108
180
    
109
181
    Otherwise, all changes for the tree are listed.
114
186
    @display_command
115
187
    def run(self, revision=None, filename=None):
116
188
        set_ui_factory()
117
 
        wt = WorkingTree.open_containing(".")[0]
118
 
        branch = wt.branch
119
 
        if revision is not None:
120
 
            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:
121
204
                tree1 = wt
122
 
                revision_id = revision[0].in_history(branch).rev_id
123
 
                tree2 = branch.repository.revision_tree(revision_id)
124
 
            elif len(revision) == 2:
125
 
                revision_id_0 = revision[0].in_history(branch).rev_id
126
 
                tree2 = branch.repository.revision_tree(revision_id_0)
127
 
                revision_id_1 = revision[1].in_history(branch).rev_id
128
 
                tree1 = branch.repository.revision_tree(revision_id_1)
129
 
        else:
130
 
            tree1 = wt
131
 
            tree2 = tree1.basis_tree()
132
 
 
133
 
        from viz.diffwin import DiffWindow
134
 
        import gtk
135
 
        window = DiffWindow()
136
 
        window.connect("destroy", lambda w: gtk.main_quit())
137
 
        window.set_diff("Working Tree", tree1, tree2)
138
 
        if filename is not None:
139
 
            tree_filename = wt.relpath(filename)
140
 
            try:
141
 
                window.set_file(tree_filename)
142
 
            except NoSuchFile:
143
 
                if (tree1.inventory.path2id(tree_filename) is None and 
144
 
                    tree2.inventory.path2id(tree_filename) is None):
145
 
                    raise NotVersionedError(filename)
146
 
                raise BzrCommandError('No changes found for file "%s"' % 
147
 
                                      filename)
148
 
        window.show()
149
 
 
150
 
        gtk.main()
151
 
 
152
 
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
 
153
237
 
154
238
class cmd_visualise(Command):
155
239
    """Graphically visualise this branch.
162
246
    """
163
247
    takes_options = [
164
248
        "revision",
165
 
        Option('limit', "maximum number of revisions to display",
 
249
        Option('limit', "Maximum number of revisions to display.",
166
250
               int, 'count')]
167
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
168
252
    aliases = [ "visualize", "vis", "viz" ]
169
253
 
170
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
171
255
        set_ui_factory()
172
 
        (branch, path) = Branch.open_containing(location)
173
 
        branch.lock_read()
174
 
        branch.repository.lock_read()
175
 
        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)
176
261
            if revision is None:
177
 
                revid = branch.last_revision()
178
 
                if revid is None:
179
 
                    return
 
262
                revids.append(br.last_revision())
180
263
            else:
181
 
                (revno, revid) = revision[0].in_history(branch)
182
 
 
183
 
            from viz.bzrkapp import BzrkApp
184
 
                
185
 
            app = BzrkApp()
186
 
            app.show(branch, revid, limit)
187
 
        finally:
188
 
            branch.repository.unlock()
189
 
            branch.unlock()
190
 
        app.main()
191
 
 
192
 
 
193
 
register_command(cmd_visualise)
194
 
 
195
 
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):
196
273
    """GTK+ annotate.
197
274
    
198
275
    Browse changes to FILENAME line by line in a GTK+ window.
200
277
 
201
278
    takes_args = ["filename", "line?"]
202
279
    takes_options = [
203
 
        Option("all", help="show annotations on all lines"),
204
 
        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."),
205
282
        Option("line", type=int, argname="lineno",
206
 
               help="jump to specified line number"),
 
283
               help="Jump to specified line number."),
207
284
        "revision",
208
285
    ]
209
286
    aliases = ["gblame", "gpraise"]
210
287
    
211
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
212
 
        pygtk = import_pygtk()
213
 
 
214
 
        try:
215
 
            import gtk
216
 
        except RuntimeError, e:
217
 
            if str(e) == "could not open display":
218
 
                raise NoDisplayError
219
 
        set_ui_factory()
 
289
        gtk = open_display()
220
290
 
221
291
        try:
222
292
            line = int(line)
226
296
 
227
297
        from annotate.gannotate import GAnnotateWindow
228
298
        from annotate.config import GAnnotateConfig
 
299
        from bzrlib.bzrdir import BzrDir
229
300
 
230
 
        try:
231
 
            (tree, path) = WorkingTree.open_containing(filename)
232
 
            branch = tree.branch
233
 
        except errors.NoWorkingTree:
234
 
            (branch, path) = Branch.open_containing(filename)
235
 
            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()
236
306
 
237
307
        file_id = tree.path2id(path)
238
308
 
241
311
        if revision is not None:
242
312
            if len(revision) != 1:
243
313
                raise BzrCommandError("Only 1 revion may be specified.")
244
 
            revision_id = revision[0].in_history(branch).rev_id
245
 
            tree = branch.repository.revision_tree(revision_id)
 
314
            revision_id = revision[0].as_revision_id(br)
 
315
            tree = br.repository.revision_tree(revision_id)
246
316
        else:
247
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
248
318
 
249
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
250
320
        window.connect("destroy", lambda w: gtk.main_quit())
251
 
        window.set_title(path + " - gannotate")
252
321
        config = GAnnotateConfig(window)
253
322
        window.show()
254
 
        branch.lock_read()
 
323
        br.lock_read()
 
324
        if wt is not None:
 
325
            wt.lock_read()
255
326
        try:
256
 
            window.annotate(tree, branch, file_id)
 
327
            window.annotate(tree, br, file_id)
 
328
            window.jump_to_line(line)
 
329
            gtk.main()
257
330
        finally:
258
 
            branch.unlock()
259
 
        window.jump_to_line(line)
260
 
        
261
 
        gtk.main()
262
 
 
263
 
register_command(cmd_gannotate)
264
 
 
265
 
class cmd_gcommit(Command):
 
331
            br.unlock()
 
332
            if wt is not None:
 
333
                wt.unlock()
 
334
 
 
335
 
 
336
 
 
337
class cmd_gcommit(GTKCommand):
266
338
    """GTK+ commit dialog
267
339
 
268
340
    Graphical user interface for committing revisions"""
269
 
    
 
341
 
 
342
    aliases = [ "gci" ]
270
343
    takes_args = []
271
344
    takes_options = []
272
345
 
273
346
    def run(self, filename=None):
274
347
        import os
275
 
        pygtk = import_pygtk()
276
 
 
277
 
        try:
278
 
            import gtk
279
 
        except RuntimeError, e:
280
 
            if str(e) == "could not open display":
281
 
                raise NoDisplayError
282
 
 
283
 
        set_ui_factory()
284
 
        from olive.commit import CommitDialog
285
 
        from bzrlib.commit import Commit
 
348
        open_display()
 
349
        from commit import CommitDialog
286
350
        from bzrlib.errors import (BzrCommandError,
287
351
                                   NotBranchError,
288
 
                                   NoWorkingTree,
289
 
                                   PointlessCommit,
290
 
                                   ConflictsInTree,
291
 
                                   StrictCommitFailed)
 
352
                                   NoWorkingTree)
292
353
 
293
354
        wt = None
294
 
        branch = None
 
355
        br = None
295
356
        try:
296
 
            (wt, path) = WorkingTree.open_containing(filename)
297
 
            branch = wt.branch
298
 
        except NotBranchError, e:
299
 
            path = e.path
 
357
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
 
358
            br = wt.branch
300
359
        except NoWorkingTree, e:
301
 
            path = e.base
302
 
            try:
303
 
                (branch, path) = Branch.open_containing(path)
304
 
            except NotBranchError, e:
305
 
                path = e.path
306
 
 
307
 
 
308
 
        commit = CommitDialog(wt, path, not branch)
309
 
        commit.run()
310
 
 
311
 
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
312
702
 
313
703
class NoDisplayError(BzrCommandError):
314
704
    """gtk could not find a proper display"""
317
707
        return "No DISPLAY. Unable to run GTK+ application."
318
708
 
319
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