/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: Aaron Bentley
  • Date: 2006-12-21 06:19:52 UTC
  • mto: This revision was merged to the branch mainline in revision 126.
  • Revision ID: aaron.bentley@utoronto.ca-20061221061952-el04e349vxfad4w7
Increase box height by 1 to fix diagonal jagginess

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()
164
 
    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
 
 
 
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
class cmd_gbranch(Command):
 
29
    """GTK+ branching.
 
30
    
 
31
    """
 
32
 
 
33
    def run(self):
 
34
        import pygtk
 
35
        pygtk.require("2.0")
 
36
        try:
 
37
            import gtk
 
38
        except RuntimeError, e:
 
39
            if str(e) == "could not open display":
 
40
                raise NoDisplayError
 
41
 
 
42
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
 
43
 
 
44
        window = BranchDialog('.')
 
45
        window.display()
 
46
 
 
47
register_command(cmd_gbranch)
 
48
 
 
49
class cmd_gdiff(Command):
 
50
    """Show differences in working tree in a GTK+ Window.
 
51
    
 
52
    Otherwise, all changes for the tree are listed.
 
53
    """
 
54
    takes_args = ['filename?']
 
55
    takes_options = ['revision']
 
56
 
 
57
    @display_command
 
58
    def run(self, revision=None, filename=None):
 
59
        wt = WorkingTree.open_containing(".")[0]
 
60
        branch = wt.branch
 
61
        if revision is not None:
 
62
            if len(revision) == 1:
 
63
                tree1 = wt
 
64
                revision_id = revision[0].in_history(branch).rev_id
 
65
                tree2 = branch.repository.revision_tree(revision_id)
 
66
            elif len(revision) == 2:
 
67
                revision_id_0 = revision[0].in_history(branch).rev_id
 
68
                tree2 = branch.repository.revision_tree(revision_id_0)
 
69
                revision_id_1 = revision[1].in_history(branch).rev_id
 
70
                tree1 = branch.repository.revision_tree(revision_id_1)
 
71
        else:
 
72
            tree1 = wt
 
73
            tree2 = tree1.basis_tree()
 
74
 
 
75
        from viz.diffwin import DiffWindow
 
76
        import gtk
 
77
        window = DiffWindow()
 
78
        window.connect("destroy", lambda w: gtk.main_quit())
 
79
        window.set_diff("Working Tree", tree1, tree2)
 
80
        if filename is not None:
 
81
            tree_filename = wt.relpath(filename)
 
82
            try:
 
83
                window.set_file(tree_filename)
 
84
            except NoSuchFile:
 
85
                if (tree1.inventory.path2id(tree_filename) is None and 
 
86
                    tree2.inventory.path2id(tree_filename) is None):
 
87
                    raise NotVersionedError(filename)
 
88
                raise BzrCommandError('No changes found for file "%s"' % 
 
89
                                      filename)
 
90
        window.show()
 
91
 
 
92
        gtk.main()
 
93
 
 
94
register_command(cmd_gdiff)
 
95
 
 
96
class cmd_visualise(Command):
 
97
    """Graphically visualise this branch.
 
98
 
 
99
    Opens a graphical window to allow you to see the history of the branch
 
100
    and relationships between revisions in a visual manner,
 
101
 
 
102
    The default starting point is latest revision on the branch, you can
 
103
    specify a starting point with -r revision.
 
104
    """
 
105
    takes_options = [
 
106
        "revision",
 
107
        Option('limit', "maximum number of revisions to display",
 
108
               int, 'count')]
 
109
    takes_args = [ "location?" ]
 
110
    aliases = [ "visualize", "vis", "viz" ]
 
111
 
 
112
    def run(self, location=".", revision=None, limit=None):
 
113
        (branch, path) = Branch.open_containing(location)
 
114
        branch.lock_read()
 
115
        branch.repository.lock_read()
 
116
        try:
 
117
            if revision is None:
 
118
                revid = branch.last_revision()
 
119
                if revid is None:
 
120
                    return
 
121
            else:
 
122
                (revno, revid) = revision[0].in_history(branch)
 
123
 
 
124
            from viz.bzrkapp import BzrkApp
 
125
                
 
126
            app = BzrkApp()
 
127
            app.show(branch, revid, limit)
 
128
        finally:
 
129
            branch.repository.unlock()
 
130
            branch.unlock()
 
131
        app.main()
 
132
 
 
133
 
 
134
register_command(cmd_visualise)
 
135
 
 
136
class cmd_gannotate(Command):
 
137
    """GTK+ annotate.
 
138
    
 
139
    Browse changes to FILENAME line by line in a GTK+ window.
 
140
    """
 
141
 
 
142
    takes_args = ["filename", "line?"]
 
143
    takes_options = [
 
144
        Option("all", help="show annotations on all lines"),
 
145
        Option("plain", help="don't highlight annotation lines"),
 
146
        Option("line", type=int, argname="lineno",
 
147
               help="jump to specified line number"),
 
148
        "revision",
 
149
    ]
 
150
    aliases = ["gblame", "gpraise"]
 
151
    
 
152
    def run(self, filename, all=False, plain=False, line='1', revision=None):
 
153
        import pygtk
 
154
        pygtk.require("2.0")
 
155
 
 
156
        try:
 
157
            import gtk
 
158
        except RuntimeError, e:
 
159
            if str(e) == "could not open display":
 
160
                raise NoDisplayError
 
161
 
 
162
        try:
 
163
            line = int(line)
 
164
        except ValueError:
 
165
            raise BzrCommandError('Line argument ("%s") is not a number.' % 
 
166
                                  line)
 
167
 
 
168
        from annotate.gannotate import GAnnotateWindow
 
169
        from annotate.config import GAnnotateConfig
 
170
 
 
171
        try:
 
172
            (tree, path) = WorkingTree.open_containing(filename)
 
173
            branch = tree.branch
 
174
        except errors.NoWorkingTree:
 
175
            (branch, path) = Branch.open_containing(filename)
 
176
            tree = branch.basis_tree()
 
177
 
 
178
        file_id = tree.path2id(path)
 
179
 
 
180
        if file_id is None:
 
181
            raise NotVersionedError(filename)
 
182
        if revision is not None:
 
183
            if len(revision) != 1:
 
184
                raise BzrCommandError("Only 1 revion may be specified.")
 
185
            revision_id = revision[0].in_history(branch).rev_id
 
186
            tree = branch.repository.revision_tree(revision_id)
 
187
        else:
 
188
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
 
189
 
 
190
        window = GAnnotateWindow(all, plain)
 
191
        window.connect("destroy", lambda w: gtk.main_quit())
 
192
        window.set_title(path + " - gannotate")
 
193
        config = GAnnotateConfig(window)
 
194
        window.show()
 
195
        branch.lock_read()
 
196
        try:
 
197
            window.annotate(tree, branch, file_id)
 
198
        finally:
 
199
            branch.unlock()
 
200
        window.jump_to_line(line)
 
201
        
 
202
        gtk.main()
 
203
 
 
204
register_command(cmd_gannotate)
 
205
 
 
206
class cmd_gcommit(Command):
 
207
    """GTK+ commit dialog
 
208
 
 
209
    Graphical user interface for committing revisions"""
 
210
    
 
211
    takes_args = []
 
212
    takes_options = []
 
213
 
 
214
    def run(self, filename=None):
 
215
        import os
 
216
        import pygtk
 
217
        pygtk.require("2.0")
 
218
 
 
219
        try:
 
220
            import gtk
 
221
        except RuntimeError, e:
 
222
            if str(e) == "could not open display":
 
223
                raise NoDisplayError
 
224
 
 
225
        from olive.commit import CommitDialog
 
226
        from bzrlib.commit import Commit
 
227
        from bzrlib.errors import (BzrCommandError,
 
228
                                   NotBranchError,
 
229
                                   NoWorkingTree,
 
230
                                   PointlessCommit,
 
231
                                   ConflictsInTree,
 
232
                                   StrictCommitFailed)
 
233
 
 
234
        wt = None
 
235
        branch = None
 
236
        try:
 
237
            (wt, path) = WorkingTree.open_containing(filename)
 
238
            branch = wt.branch
 
239
        except NotBranchError, e:
 
240
            path = e.path
 
241
        except NoWorkingTree, e:
 
242
            path = e.base
 
243
            try:
 
244
                (branch, path) = Branch.open_containing(path)
 
245
            except NotBranchError, e:
 
246
                path = e.path
 
247
 
 
248
        dialog = CommitDialog(wt, path, not branch)
 
249
        if dialog.display():
 
250
            dialog.window.connect("destroy", lambda w: gtk.main_quit())
 
251
            gtk.main()
 
252
 
 
253
register_command(cmd_gcommit)
 
254
 
 
255
class NoDisplayError(BzrCommandError):
 
256
    """gtk could not find a proper display"""
 
257
 
 
258
    def __str__(self):
 
259
        return "No DISPLAY. gannotate is disabled."