/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: 2012-07-09 15:23:26 UTC
  • mto: This revision was merged to the branch mainline in revision 794.
  • Revision ID: jelmer@samba.org-20120709152326-dzxb8zoz0btull7n
Remove bzr-notify.

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.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.13.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 = wt.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."
 
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