/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: 2006-12-13 12:29:59 UTC
  • mto: (66.2.16 bzr-gtk-meld)
  • mto: This revision was merged to the branch mainline in revision 118.
  • Revision ID: jelmer@samba.org-20061213122959-h9yluqyu0ijelmb0
Fix desktop file. Patch from Toshio Kuratomi. Fixes #75278.

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