/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

Commit messages never contain config options

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
18
 
from bzrlib.commands import Command, register_command, display_command
19
 
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
20
 
from bzrlib.commands import Command, register_command
21
 
from bzrlib.option import Option
22
 
from bzrlib.branch import Branch
23
 
from bzrlib.workingtree import WorkingTree
24
 
from bzrlib.bzrdir import BzrDir
25
 
 
26
 
__version__ = '0.13.0'
27
 
 
28
 
 
29
 
def import_pygtk():
 
15
"""Graphical support for Bazaar using GTK.
 
16
 
 
17
This plugin includes:
 
18
gannotate         GTK+ annotate.
 
19
gbranch           GTK+ branching.
 
20
gcheckout         GTK+ checkout.
 
21
gcommit           GTK+ commit dialog.
 
22
gconflicts        GTK+ conflicts.
 
23
gdiff             Show differences in working tree in a GTK+ Window.
 
24
ginit             Initialise a new branch.
 
25
gloom             GTK+ loom browse dialog
 
26
gmerge            GTK+ merge dialog
 
27
gmissing          GTK+ missing revisions dialog.
 
28
gpreferences      GTK+ preferences dialog.
 
29
gpush             GTK+ push.
 
30
gsend             GTK+ send merge directive.
 
31
gstatus           GTK+ status dialog.
 
32
gtags             Manage branch tags.
 
33
visualise         Graphically visualise this branch.
 
34
"""
 
35
 
 
36
from __future__ import absolute_import
 
37
 
 
38
import os
 
39
import sys
 
40
 
 
41
if getattr(sys, "frozen", None) is not None: # we run bzr.exe
 
42
 
 
43
    # FIXME: Unless a better packaging solution is found, the following
 
44
    # provides a workaround for https://bugs.launchpad.net/bzr/+bug/388790 Also
 
45
    # see https://code.edge.launchpad.net/~vila/bzr-gtk/388790-windows-setup
 
46
    # for more details about while it's needed.
 
47
 
 
48
    # NOTE: _lib must be ahead of bzrlib or sax.saxutils (in olive) fails
 
49
    here = os.path.dirname(__file__)
 
50
    sys.path.insert(0, os.path.join(here, '_lib'))
 
51
    sys.path.append(os.path.join(here, '_lib/gtk-2.0'))
 
52
 
 
53
 
 
54
import bzrlib
 
55
import bzrlib.api
 
56
from bzrlib.commands import plugin_cmds
 
57
 
 
58
from bzrlib.plugins.gtk.info import (
 
59
    bzr_plugin_version as version_info,
 
60
    bzr_compatible_versions,
 
61
    )
 
62
 
 
63
if version_info[3] == 'final':
 
64
    version_string = '%d.%d.%d' % version_info[:3]
 
65
else:
 
66
    version_string = '%d.%d.%d%s%d' % version_info
 
67
__version__ = version_string
 
68
 
 
69
bzrlib.api.require_any_api(bzrlib, bzr_compatible_versions)
 
70
 
 
71
if __name__ != 'bzrlib.plugins.gtk':
 
72
    from bzrlib.trace import warning
 
73
    warning("Not running as bzrlib.plugins.gtk, things may break.")
 
74
 
 
75
 
 
76
def set_ui_factory():
 
77
    from bzrlib.plugins.gtk.ui import GtkUIFactory
 
78
    import bzrlib.ui
 
79
    bzrlib.ui.ui_factory = GtkUIFactory()
 
80
 
 
81
 
 
82
def data_basedirs():
 
83
    return [os.path.dirname(__file__),
 
84
             "/usr/share/bzr-gtk", 
 
85
             "/usr/local/share/bzr-gtk"]
 
86
 
 
87
 
 
88
def data_path(*args):
 
89
    for basedir in data_basedirs():
 
90
        path = os.path.join(basedir, *args)
 
91
        if os.path.exists(path):
 
92
            return path
 
93
    return None
 
94
 
 
95
 
 
96
def icon_path(*args):
 
97
    return data_path(os.path.join('icons', *args))
 
98
 
 
99
 
 
100
commands = {
 
101
    "gannotate": ["gblame", "gpraise"],
 
102
    "gbranch": [],
 
103
    "gcheckout": [],
 
104
    "gcommit": ["gci"],
 
105
    "gconflicts": [],
 
106
    "gdiff": [],
 
107
    "ginit": [],
 
108
    "gmerge": [],
 
109
    "gmissing": [],
 
110
    "gpreferences": [],
 
111
    "gpush": [],
 
112
    "gsend": [],
 
113
    "gstatus": ["gst"],
 
114
    "gtags": [],
 
115
    "visualise": ["visualize", "vis", "viz", 'glog'],
 
116
    }
 
117
 
 
118
try:
 
119
    from bzrlib.plugins import loom
 
120
except ImportError:
 
121
    pass # Loom plugin doesn't appear to be present
 
122
else:
 
123
    commands["gloom"] = []
 
124
 
 
125
for cmd, aliases in commands.iteritems():
 
126
    plugin_cmds.register_lazy("cmd_%s" % cmd, aliases,
 
127
                              "bzrlib.plugins.gtk.commands")
 
128
 
 
129
def save_commit_messages(*args):
 
130
    from bzrlib.plugins.gtk import commitmsgs
 
131
    commitmsgs.save_commit_messages(*args)
 
132
 
 
133
try:
 
134
    from bzrlib.hooks import install_lazy_named_hook
 
135
except ImportError:
 
136
    from bzrlib.branch import Branch
 
137
    Branch.hooks.install_named_hook('post_uncommit',
 
138
                                    save_commit_messages,
 
139
                                    "Saving commit messages for gcommit")
 
140
else:
 
141
    install_lazy_named_hook("bzrlib.branch", "Branch.hooks",
 
142
        'post_uncommit', save_commit_messages, "Saving commit messages for gcommit")
 
143
 
 
144
try:
 
145
    from bzrlib.registry import register_lazy
 
146
except ImportError:
 
147
    from bzrlib import config
 
148
    option_registry = getattr(config, "option_registry", None)
 
149
    if option_registry is not None:
 
150
        config.option_registry.register_lazy('nautilus_integration',
 
151
                'bzrlib.plugins.gtk.config', 'opt_nautilus_integration')
 
152
else:
 
153
    register_lazy("bzrlib.config", "option_registry",
 
154
        'nautilus_integration', 'bzrlib.plugins.gtk.config',
 
155
        'opt_nautilus_integration')
 
156
 
 
157
 
 
158
def load_tests(basic_tests, module, loader):
 
159
    testmod_names = [
 
160
        'tests',
 
161
        ]
 
162
    import sys
 
163
    default_encoding = sys.getdefaultencoding()
30
164
    try:
31
 
        import pygtk
32
 
    except ImportError:
33
 
        raise errors.BzrCommandError("PyGTK not installed.")
34
 
    pygtk.require('2.0')
35
 
    return pygtk
36
 
 
37
 
 
38
 
class cmd_gbranch(Command):
39
 
    """GTK+ branching.
40
 
    
41
 
    """
42
 
 
43
 
    def run(self):
44
 
        pygtk = import_pygtk()
45
 
        try:
46
 
            import gtk
47
 
        except RuntimeError, e:
48
 
            if str(e) == "could not open display":
49
 
                raise NoDisplayError
50
 
 
51
 
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
52
 
 
53
 
        window = BranchDialog('.')
54
 
        window.display()
55
 
 
56
 
register_command(cmd_gbranch)
57
 
 
58
 
class cmd_gdiff(Command):
59
 
    """Show differences in working tree in a GTK+ Window.
60
 
    
61
 
    Otherwise, all changes for the tree are listed.
62
 
    """
63
 
    takes_args = ['filename?']
64
 
    takes_options = ['revision']
65
 
 
66
 
    @display_command
67
 
    def run(self, revision=None, filename=None):
68
 
        wt = WorkingTree.open_containing(".")[0]
69
 
        branch = wt.branch
70
 
        if revision is not None:
71
 
            if len(revision) == 1:
72
 
                tree1 = wt
73
 
                revision_id = revision[0].in_history(branch).rev_id
74
 
                tree2 = branch.repository.revision_tree(revision_id)
75
 
            elif len(revision) == 2:
76
 
                revision_id_0 = revision[0].in_history(branch).rev_id
77
 
                tree2 = branch.repository.revision_tree(revision_id_0)
78
 
                revision_id_1 = revision[1].in_history(branch).rev_id
79
 
                tree1 = branch.repository.revision_tree(revision_id_1)
80
 
        else:
81
 
            tree1 = wt
82
 
            tree2 = tree1.basis_tree()
83
 
 
84
 
        from viz.diffwin import DiffWindow
85
 
        import gtk
86
 
        window = DiffWindow()
87
 
        window.connect("destroy", lambda w: gtk.main_quit())
88
 
        window.set_diff("Working Tree", tree1, tree2)
89
 
        if filename is not None:
90
 
            tree_filename = wt.relpath(filename)
91
 
            try:
92
 
                window.set_file(tree_filename)
93
 
            except NoSuchFile:
94
 
                if (tree1.inventory.path2id(tree_filename) is None and 
95
 
                    tree2.inventory.path2id(tree_filename) is None):
96
 
                    raise NotVersionedError(filename)
97
 
                raise BzrCommandError('No changes found for file "%s"' % 
98
 
                                      filename)
99
 
        window.show()
100
 
 
101
 
        gtk.main()
102
 
 
103
 
register_command(cmd_gdiff)
104
 
 
105
 
class cmd_visualise(Command):
106
 
    """Graphically visualise this branch.
107
 
 
108
 
    Opens a graphical window to allow you to see the history of the branch
109
 
    and relationships between revisions in a visual manner,
110
 
 
111
 
    The default starting point is latest revision on the branch, you can
112
 
    specify a starting point with -r revision.
113
 
    """
114
 
    takes_options = [
115
 
        "revision",
116
 
        Option('limit', "maximum number of revisions to display",
117
 
               int, 'count')]
118
 
    takes_args = [ "location?" ]
119
 
    aliases = [ "visualize", "vis", "viz" ]
120
 
 
121
 
    def run(self, location=".", revision=None, limit=None):
122
 
        (branch, path) = Branch.open_containing(location)
123
 
        branch.lock_read()
124
 
        branch.repository.lock_read()
125
 
        try:
126
 
            if revision is None:
127
 
                revid = branch.last_revision()
128
 
                if revid is None:
129
 
                    return
130
 
            else:
131
 
                (revno, revid) = revision[0].in_history(branch)
132
 
 
133
 
            from viz.bzrkapp import BzrkApp
134
 
                
135
 
            app = BzrkApp()
136
 
            app.show(branch, revid, limit)
137
 
        finally:
138
 
            branch.repository.unlock()
139
 
            branch.unlock()
140
 
        app.main()
141
 
 
142
 
 
143
 
register_command(cmd_visualise)
144
 
 
145
 
class cmd_gannotate(Command):
146
 
    """GTK+ annotate.
147
 
    
148
 
    Browse changes to FILENAME line by line in a GTK+ window.
149
 
    """
150
 
 
151
 
    takes_args = ["filename", "line?"]
152
 
    takes_options = [
153
 
        Option("all", help="show annotations on all lines"),
154
 
        Option("plain", help="don't highlight annotation lines"),
155
 
        Option("line", type=int, argname="lineno",
156
 
               help="jump to specified line number"),
157
 
        "revision",
158
 
    ]
159
 
    aliases = ["gblame", "gpraise"]
160
 
    
161
 
    def run(self, filename, all=False, plain=False, line='1', revision=None):
162
 
        pygtk = import_pygtk()
163
 
 
164
 
        try:
165
 
            import gtk
166
 
        except RuntimeError, e:
167
 
            if str(e) == "could not open display":
168
 
                raise NoDisplayError
169
 
 
170
 
        try:
171
 
            line = int(line)
172
 
        except ValueError:
173
 
            raise BzrCommandError('Line argument ("%s") is not a number.' % 
174
 
                                  line)
175
 
 
176
 
        from annotate.gannotate import GAnnotateWindow
177
 
        from annotate.config import GAnnotateConfig
178
 
 
179
 
        try:
180
 
            (tree, path) = WorkingTree.open_containing(filename)
181
 
            branch = tree.branch
182
 
        except errors.NoWorkingTree:
183
 
            (branch, path) = Branch.open_containing(filename)
184
 
            tree = branch.basis_tree()
185
 
 
186
 
        file_id = tree.path2id(path)
187
 
 
188
 
        if file_id is None:
189
 
            raise NotVersionedError(filename)
190
 
        if revision is not None:
191
 
            if len(revision) != 1:
192
 
                raise BzrCommandError("Only 1 revion may be specified.")
193
 
            revision_id = revision[0].in_history(branch).rev_id
194
 
            tree = branch.repository.revision_tree(revision_id)
195
 
        else:
196
 
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
197
 
 
198
 
        window = GAnnotateWindow(all, plain)
199
 
        window.connect("destroy", lambda w: gtk.main_quit())
200
 
        window.set_title(path + " - gannotate")
201
 
        config = GAnnotateConfig(window)
202
 
        window.show()
203
 
        branch.lock_read()
204
 
        try:
205
 
            window.annotate(tree, branch, file_id)
206
 
        finally:
207
 
            branch.unlock()
208
 
        window.jump_to_line(line)
209
 
        
210
 
        gtk.main()
211
 
 
212
 
register_command(cmd_gannotate)
213
 
 
214
 
class cmd_gcommit(Command):
215
 
    """GTK+ commit dialog
216
 
 
217
 
    Graphical user interface for committing revisions"""
218
 
    
219
 
    takes_args = []
220
 
    takes_options = []
221
 
 
222
 
    def run(self, filename=None):
223
 
        import os
224
 
        pygtk = import_pygtk()
225
 
 
226
 
        try:
227
 
            import gtk
228
 
        except RuntimeError, e:
229
 
            if str(e) == "could not open display":
230
 
                raise NoDisplayError
231
 
 
232
 
        from olive.commit import CommitDialog
233
 
        from bzrlib.commit import Commit
234
 
        from bzrlib.errors import (BzrCommandError,
235
 
                                   NotBranchError,
236
 
                                   NoWorkingTree,
237
 
                                   PointlessCommit,
238
 
                                   ConflictsInTree,
239
 
                                   StrictCommitFailed)
240
 
 
241
 
        wt = None
242
 
        branch = None
243
 
        try:
244
 
            (wt, path) = WorkingTree.open_containing(filename)
245
 
            branch = wt.branch
246
 
        except NotBranchError, e:
247
 
            path = e.path
248
 
        except NoWorkingTree, e:
249
 
            path = e.base
250
 
            try:
251
 
                (branch, path) = Branch.open_containing(path)
252
 
            except NotBranchError, e:
253
 
                path = e.path
254
 
 
255
 
        dialog = CommitDialog(wt, path, not branch)
256
 
        if dialog.display():
257
 
            dialog.window.connect("destroy", lambda w: gtk.main_quit())
258
 
            gtk.main()
259
 
 
260
 
register_command(cmd_gcommit)
261
 
 
262
 
class NoDisplayError(BzrCommandError):
263
 
    """gtk could not find a proper display"""
264
 
 
265
 
    def __str__(self):
266
 
        return "No DISPLAY. gannotate is disabled."
 
165
        result = basic_tests
 
166
        try:
 
167
            import gi.repository.Gtk
 
168
        except ImportError:
 
169
            return basic_tests
 
170
        basic_tests.addTest(loader.loadTestsFromModuleNames(
 
171
                ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
 
172
    finally:
 
173
        if sys.getdefaultencoding() != default_encoding:
 
174
            reload(sys)
 
175
            sys.setdefaultencoding(default_encoding)
 
176
    return basic_tests
 
177