/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: Vincent Ladeuil
  • Date: 2007-02-17 09:02:59 UTC
  • mto: (157.1.8 trunk)
  • mto: This revision was merged to the branch mainline in revision 160.
  • Revision ID: v.ladeuil+lp@free.fr-20070217090259-kmay8g9eu688qw0l
Rename variable 'branch' to 'br' where it conflicts with 'branch' module

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
12
12
# along with this program; if not, write to the Free Software
13
13
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
14
14
 
15
 
"""Graphical support for Bazaar using GTK.
16
 
 
17
 
This plugin includes:
18
 
commit-notify     Start the graphical notifier of commits.
19
 
gannotate         GTK+ annotate. 
20
 
gbranch           GTK+ branching. 
21
 
gcheckout         GTK+ checkout. 
22
 
gcommit           GTK+ commit dialog.
23
 
gconflicts        GTK+ 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
 
15
"""GTK+ frontends to Bazaar commands """
36
16
 
37
17
import bzrlib
38
18
 
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)
 
19
__version__ = '0.15.0'
 
20
version_info = tuple(int(n) for n in __version__.split('.'))
 
21
 
48
22
 
49
23
def check_bzrlib_version(desired):
50
24
    """Check that bzrlib is compatible.
51
25
 
52
26
    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.
53
30
    """
 
31
    desired_plus = (desired[0], desired[1]+1)
54
32
    bzrlib_version = bzrlib.version_info[:2]
 
33
    if bzrlib_version == desired:
 
34
        return
55
35
    try:
56
36
        from bzrlib.trace import warning
57
37
    except ImportError:
58
38
        # get the message out any way we can
59
39
        from warnings import warn as warning
60
40
    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'
 
41
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
63
42
                ' %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)
 
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])
69
54
 
70
55
from bzrlib.trace import warning
71
56
if __name__ != 'bzrlib.plugins.gtk':
75
60
lazy_import(globals(), """
76
61
from bzrlib import (
77
62
    branch,
78
 
    builtins,
79
63
    errors,
80
 
    merge_directive,
81
64
    workingtree,
82
65
    )
83
66
""")
84
67
 
85
68
from bzrlib.commands import Command, register_command, display_command
86
69
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
 
70
from bzrlib.commands import Command, register_command
87
71
from bzrlib.option import Option
 
72
from bzrlib.bzrdir import BzrDir
88
73
 
89
74
import os.path
90
75
 
98
83
 
99
84
 
100
85
def set_ui_factory():
101
 
    import_pygtk()
 
86
    pygtk = import_pygtk()
102
87
    from ui import GtkUIFactory
103
88
    import bzrlib.ui
104
89
    bzrlib.ui.ui_factory = GtkUIFactory()
105
90
 
106
91
 
107
 
def data_path():
108
 
    return os.path.dirname(__file__)
109
 
 
110
 
 
111
 
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):
 
92
class cmd_gbranch(Command):
143
93
    """GTK+ branching.
144
94
    
145
95
    """
146
96
 
147
 
    def get_gtk_dialog(self, path):
 
97
    def run(self):
 
98
        pygtk = import_pygtk()
 
99
        try:
 
100
            import gtk
 
101
        except RuntimeError, e:
 
102
            if str(e) == "could not open display":
 
103
                raise NoDisplayError
 
104
 
148
105
        from bzrlib.plugins.gtk.branch import BranchDialog
149
 
        return BranchDialog(path)
150
 
 
151
 
 
152
 
class cmd_gcheckout(GTKCommand):
 
106
 
 
107
        set_ui_factory()
 
108
        dialog = BranchDialog(os.path.abspath('.'))
 
109
        dialog.run()
 
110
 
 
111
register_command(cmd_gbranch)
 
112
 
 
113
class cmd_gcheckout(Command):
153
114
    """ GTK+ checkout.
154
115
    
155
116
    """
156
117
    
157
 
    def get_gtk_dialog(self, path):
 
118
    def run(self):
 
119
        pygtk = import_pygtk()
 
120
        try:
 
121
            import gtk
 
122
        except RuntimeError, e:
 
123
            if str(e) == "could not open display":
 
124
                raise NoDisplayError
 
125
 
158
126
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
159
 
        return CheckoutDialog(path)
160
 
 
161
 
 
162
 
 
163
 
class cmd_gpush(GTKCommand):
 
127
 
 
128
        set_ui_factory()
 
129
        dialog = CheckoutDialog(os.path.abspath('.'))
 
130
        dialog.run()
 
131
 
 
132
register_command(cmd_gcheckout)
 
133
 
 
134
class cmd_gpush(Command):
164
135
    """ GTK+ push.
165
136
    
166
137
    """
168
139
 
169
140
    def run(self, location="."):
170
141
        (br, path) = branch.Branch.open_containing(location)
171
 
        open_display()
 
142
 
 
143
        pygtk = import_pygtk()
 
144
        try:
 
145
            import gtk
 
146
        except RuntimeError, e:
 
147
            if str(e) == "could not open display":
 
148
                raise NoDisplayError
 
149
 
172
150
        from push import PushDialog
173
 
        dialog = PushDialog(br.repository, br.last_revision(), br)
 
151
 
 
152
        set_ui_factory()
 
153
        dialog = PushDialog(br)
174
154
        dialog.run()
175
155
 
176
 
 
177
 
 
178
 
class cmd_gdiff(GTKCommand):
 
156
register_command(cmd_gpush)
 
157
 
 
158
class cmd_gdiff(Command):
179
159
    """Show differences in working tree in a GTK+ Window.
180
160
    
181
161
    Otherwise, all changes for the tree are listed.
187
167
    def run(self, revision=None, filename=None):
188
168
        set_ui_factory()
189
169
        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:
 
170
        branch = wt.branch
 
171
        if revision is not None:
 
172
            if len(revision) == 1:
204
173
                tree1 = wt
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
 
 
 
174
                revision_id = revision[0].in_history(branch).rev_id
 
175
                tree2 = branch.repository.revision_tree(revision_id)
 
176
            elif len(revision) == 2:
 
177
                revision_id_0 = revision[0].in_history(branch).rev_id
 
178
                tree2 = branch.repository.revision_tree(revision_id_0)
 
179
                revision_id_1 = revision[1].in_history(branch).rev_id
 
180
                tree1 = branch.repository.revision_tree(revision_id_1)
 
181
        else:
 
182
            tree1 = wt
 
183
            tree2 = tree1.basis_tree()
 
184
 
 
185
        from diff import DiffWindow
 
186
        import gtk
 
187
        window = DiffWindow()
 
188
        window.connect("destroy", gtk.main_quit)
 
189
        window.set_diff("Working Tree", tree1, tree2)
 
190
        if filename is not None:
 
191
            tree_filename = wt.relpath(filename)
 
192
            try:
 
193
                window.set_file(tree_filename)
 
194
            except NoSuchFile:
 
195
                if (tree1.inventory.path2id(tree_filename) is None and 
 
196
                    tree2.inventory.path2id(tree_filename) is None):
 
197
                    raise NotVersionedError(filename)
 
198
                raise BzrCommandError('No changes found for file "%s"' % 
 
199
                                      filename)
 
200
        window.show()
 
201
 
 
202
        gtk.main()
 
203
 
 
204
register_command(cmd_gdiff)
237
205
 
238
206
class cmd_visualise(Command):
239
207
    """Graphically visualise this branch.
246
214
    """
247
215
    takes_options = [
248
216
        "revision",
249
 
        Option('limit', "Maximum number of revisions to display.",
 
217
        Option('limit', "maximum number of revisions to display",
250
218
               int, 'count')]
251
 
    takes_args = [ "locations*" ]
 
219
    takes_args = [ "location?" ]
252
220
    aliases = [ "visualize", "vis", "viz" ]
253
221
 
254
 
    def run(self, locations_list, revision=None, limit=None):
 
222
    def run(self, location=".", revision=None, limit=None):
255
223
        set_ui_factory()
256
 
        if locations_list is None:
257
 
            locations_list = ["."]
258
 
        revids = []
259
 
        for location in locations_list:
260
 
            (br, path) = branch.Branch.open_containing(location)
 
224
        (br, path) = branch.Branch.open_containing(location)
 
225
        br.lock_read()
 
226
        br.repository.lock_read()
 
227
        try:
261
228
            if revision is None:
262
 
                revids.append(br.last_revision())
 
229
                revid = br.last_revision()
 
230
                if revid is None:
 
231
                    return
263
232
            else:
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):
 
233
                (revno, revid) = revision[0].in_history(br)
 
234
 
 
235
            from viz.branchwin import BranchWindow
 
236
            import gtk
 
237
                
 
238
            pp = BranchWindow()
 
239
            pp.set_branch(br, revid, limit)
 
240
            pp.connect("destroy", lambda w: gtk.main_quit())
 
241
            pp.show()
 
242
            gtk.main()
 
243
        finally:
 
244
            br.repository.unlock()
 
245
            br.unlock()
 
246
 
 
247
 
 
248
register_command(cmd_visualise)
 
249
 
 
250
class cmd_gannotate(Command):
273
251
    """GTK+ annotate.
274
252
    
275
253
    Browse changes to FILENAME line by line in a GTK+ window.
277
255
 
278
256
    takes_args = ["filename", "line?"]
279
257
    takes_options = [
280
 
        Option("all", help="Show annotations on all lines."),
281
 
        Option("plain", help="Don't highlight annotation lines."),
 
258
        Option("all", help="show annotations on all lines"),
 
259
        Option("plain", help="don't highlight annotation lines"),
282
260
        Option("line", type=int, argname="lineno",
283
 
               help="Jump to specified line number."),
 
261
               help="jump to specified line number"),
284
262
        "revision",
285
263
    ]
286
264
    aliases = ["gblame", "gpraise"]
287
265
    
288
266
    def run(self, filename, all=False, plain=False, line='1', revision=None):
289
 
        gtk = open_display()
 
267
        pygtk = import_pygtk()
 
268
 
 
269
        try:
 
270
            import gtk
 
271
        except RuntimeError, e:
 
272
            if str(e) == "could not open display":
 
273
                raise NoDisplayError
 
274
        set_ui_factory()
290
275
 
291
276
        try:
292
277
            line = int(line)
296
281
 
297
282
        from annotate.gannotate import GAnnotateWindow
298
283
        from annotate.config import GAnnotateConfig
299
 
        from bzrlib.bzrdir import BzrDir
300
284
 
301
 
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
302
 
        if wt is not None:
303
 
            tree = wt
304
 
        else:
 
285
        try:
 
286
            (tree, path) = workingtree.WorkingTree.open_containing(filename)
 
287
            br = tree.branch
 
288
        except errors.NoWorkingTree:
 
289
            (br, path) = branch.Branch.open_containing(filename)
305
290
            tree = br.basis_tree()
306
291
 
307
292
        file_id = tree.path2id(path)
311
296
        if revision is not None:
312
297
            if len(revision) != 1:
313
298
                raise BzrCommandError("Only 1 revion may be specified.")
314
 
            revision_id = revision[0].as_revision_id(br)
 
299
            revision_id = revision[0].in_history(br).rev_id
315
300
            tree = br.repository.revision_tree(revision_id)
316
301
        else:
317
302
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
318
303
 
319
 
        window = GAnnotateWindow(all, plain, branch=br)
 
304
        window = GAnnotateWindow(all, plain)
320
305
        window.connect("destroy", lambda w: gtk.main_quit())
 
306
        window.set_title(path + " - gannotate")
321
307
        config = GAnnotateConfig(window)
322
308
        window.show()
323
309
        br.lock_read()
324
 
        if wt is not None:
325
 
            wt.lock_read()
326
310
        try:
327
311
            window.annotate(tree, br, file_id)
328
 
            window.jump_to_line(line)
329
 
            gtk.main()
330
312
        finally:
331
313
            br.unlock()
332
 
            if wt is not None:
333
 
                wt.unlock()
334
 
 
335
 
 
336
 
 
337
 
class cmd_gcommit(GTKCommand):
 
314
        window.jump_to_line(line)
 
315
        
 
316
        gtk.main()
 
317
 
 
318
register_command(cmd_gannotate)
 
319
 
 
320
class cmd_gcommit(Command):
338
321
    """GTK+ commit dialog
339
322
 
340
323
    Graphical user interface for committing revisions"""
341
 
 
 
324
    
342
325
    aliases = [ "gci" ]
343
326
    takes_args = []
344
327
    takes_options = []
345
328
 
346
329
    def run(self, filename=None):
347
330
        import os
348
 
        open_display()
 
331
        pygtk = import_pygtk()
 
332
 
 
333
        try:
 
334
            import gtk
 
335
        except RuntimeError, e:
 
336
            if str(e) == "could not open display":
 
337
                raise NoDisplayError
 
338
 
 
339
        set_ui_factory()
349
340
        from commit import CommitDialog
 
341
        from bzrlib.commit import Commit
350
342
        from bzrlib.errors import (BzrCommandError,
351
343
                                   NotBranchError,
352
 
                                   NoWorkingTree)
 
344
                                   NoWorkingTree,
 
345
                                   PointlessCommit,
 
346
                                   ConflictsInTree,
 
347
                                   StrictCommitFailed)
353
348
 
354
349
        wt = None
355
350
        br = None
356
351
        try:
357
352
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
358
353
            br = wt.branch
 
354
        except NotBranchError, e:
 
355
            path = e.path
359
356
        except NoWorkingTree, e:
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):
 
357
            path = e.base
 
358
            try:
 
359
                (br, path) = branch.Branch.open_containing(path)
 
360
            except NotBranchError, e:
 
361
                path = e.path
 
362
 
 
363
 
 
364
        commit = CommitDialog(wt, path, not br)
 
365
        commit.run()
 
366
 
 
367
register_command(cmd_gcommit)
 
368
 
 
369
class cmd_gstatus(Command):
378
370
    """GTK+ status dialog
379
371
 
380
372
    Graphical user interface for showing status 
382
374
    
383
375
    aliases = [ "gst" ]
384
376
    takes_args = ['PATH?']
385
 
    takes_options = ['revision']
 
377
    takes_options = []
386
378
 
387
 
    def run(self, path='.', revision=None):
 
379
    def run(self, path='.'):
388
380
        import os
389
 
        gtk = open_display()
 
381
        pygtk = import_pygtk()
 
382
 
 
383
        try:
 
384
            import gtk
 
385
        except RuntimeError, e:
 
386
            if str(e) == "could not open display":
 
387
                raise NoDisplayError
 
388
 
 
389
        set_ui_factory()
390
390
        from status import StatusDialog
391
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)
 
392
        status = StatusDialog(wt, wt_path)
403
393
        status.connect("destroy", gtk.main_quit)
404
394
        status.run()
405
395
 
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.
 
396
register_command(cmd_gstatus)
 
397
 
 
398
class cmd_gconflicts(Command):
 
399
    """ GTK+ push.
429
400
    
430
 
    Select files from the list of conflicts and run an external utility to
431
 
    resolve them.
432
401
    """
433
402
    def run(self):
434
403
        (wt, path) = workingtree.WorkingTree.open_containing('.')
435
 
        open_display()
 
404
        
 
405
        pygtk = import_pygtk()
 
406
        try:
 
407
            import gtk
 
408
        except RuntimeError, e:
 
409
            if str(e) == "could not open display":
 
410
                raise NoDisplayError
 
411
 
436
412
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
 
413
 
 
414
        set_ui_factory()
437
415
        dialog = ConflictsDialog(wt)
438
416
        dialog.run()
439
417
 
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
 
 
 
418
register_command(cmd_gconflicts)
695
419
 
696
420
import gettext
697
421
gettext.install('olive-gtk')
698
422
 
699
 
# Let's create a specialized alias to protect '_' from being erased by other
700
 
# uses of '_' as an anonymous variable (think pdb for one).
701
 
_i18n = gettext.gettext
702
 
 
703
423
class NoDisplayError(BzrCommandError):
704
424
    """gtk could not find a proper display"""
705
425
 
706
426
    def __str__(self):
707
427
        return "No DISPLAY. Unable to run GTK+ application."
708
428
 
709
 
 
710
429
def test_suite():
711
430
    from unittest import TestSuite
712
431
    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)
 
432
    result = TestSuite()
 
433
    result.addTest(tests.test_suite())
726
434
    return result