/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-01-26 11:48:08 UTC
  • mfrom: (66.6.7 bzr-gtk-meld)
  • Revision ID: v.ladeuil+lp@free.fr-20070126114808-qvsp1nbo1g1gz6dp
merge trunk

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
 
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()
 
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():
164
30
    try:
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
 
 
 
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."