/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: Curtis Hovey
  • Date: 2012-03-11 18:24:06 UTC
  • mto: This revision was merged to the branch mainline in revision 785.
  • Revision ID: sinzui.is@verizon.net-20120311182406-f4jqpff65b30g3al
Create the mnemonic for the button label.

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.11.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 clone import CloneDialog
42
 
 
43
 
        window = CloneDialog()
44
 
        if window.run() == gtk.RESPONSE_OK:
45
 
            bzrdir = BzrDir.open(window.url)
46
 
            bzrdir.sprout(window.dest_path)
47
 
 
48
 
register_command(cmd_gbranch)
49
 
 
50
 
class cmd_gdiff(Command):
51
 
    """Show differences in working tree in a GTK+ Window.
52
 
    
53
 
    Otherwise, all changes for the tree are listed.
54
 
    """
55
 
    takes_args = ['filename?']
56
 
    takes_options = ['revision']
57
 
 
58
 
    @display_command
59
 
    def run(self, revision=None, filename=None):
60
 
        wt = WorkingTree.open_containing(".")[0]
61
 
        branch = wt.branch
62
 
        if revision is not None:
63
 
            if len(revision) == 1:
64
 
                tree1 = wt
65
 
                revision_id = revision[0].in_history(branch).rev_id
66
 
                tree2 = branch.repository.revision_tree(revision_id)
67
 
            elif len(revision) == 2:
68
 
                revision_id_0 = revision[0].in_history(branch).rev_id
69
 
                tree2 = branch.repository.revision_tree(revision_id_0)
70
 
                revision_id_1 = revision[1].in_history(branch).rev_id
71
 
                tree1 = branch.repository.revision_tree(revision_id_1)
72
 
        else:
73
 
            tree1 = wt
74
 
            tree2 = tree1.basis_tree()
75
 
 
76
 
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
77
 
        import gtk
78
 
        window = DiffWindow()
79
 
        window.connect("destroy", lambda w: gtk.main_quit())
80
 
        window.set_diff("Working Tree", tree1, tree2)
81
 
        if filename is not None:
82
 
            tree_filename = tree1.relpath(filename)
83
 
            try:
84
 
                window.set_file(tree_filename)
85
 
            except NoSuchFile:
86
 
                if (tree1.inventory.path2id(tree_filename) is None and 
87
 
                    tree2.inventory.path2id(tree_filename) is None):
88
 
                    raise NotVersionedError(filename)
89
 
                raise BzrCommandError('No changes found for file "%s"' % 
90
 
                                      filename)
91
 
        window.show()
92
 
 
93
 
        gtk.main()
94
 
 
95
 
register_command(cmd_gdiff)
96
 
 
97
 
class cmd_visualise(Command):
98
 
    """Graphically visualise this branch.
99
 
 
100
 
    Opens a graphical window to allow you to see the history of the branch
101
 
    and relationships between revisions in a visual manner,
102
 
 
103
 
    The default starting point is latest revision on the branch, you can
104
 
    specify a starting point with -r revision.
105
 
    """
106
 
    takes_options = [
107
 
        "revision",
108
 
        Option('limit', "maximum number of revisions to display",
109
 
               int, 'count')]
110
 
    takes_args = [ "location?" ]
111
 
    aliases = [ "visualize", "vis", "viz" ]
112
 
 
113
 
    def run(self, location=".", revision=None, limit=None):
114
 
        (branch, path) = Branch.open_containing(location)
115
 
        branch.lock_read()
116
 
        branch.repository.lock_read()
117
 
        try:
118
 
            if revision is None:
119
 
                revid = branch.last_revision()
120
 
                if revid is None:
121
 
                    return
122
 
            else:
123
 
                (revno, revid) = revision[0].in_history(branch)
124
 
 
125
 
            from viz.bzrkapp import BzrkApp
126
 
                
127
 
            app = BzrkApp()
128
 
            app.show(branch, revid, limit)
129
 
        finally:
130
 
            branch.repository.unlock()
131
 
            branch.unlock()
132
 
        app.main()
133
 
 
134
 
 
135
 
register_command(cmd_visualise)
136
 
 
137
 
class cmd_gannotate(Command):
138
 
    """GTK+ annotate.
139
 
    
140
 
    Browse changes to FILENAME line by line in a GTK+ window.
141
 
    """
142
 
 
143
 
    takes_args = ["filename", "line?"]
144
 
    takes_options = [
145
 
        Option("all", help="show annotations on all lines"),
146
 
        Option("plain", help="don't highlight annotation lines"),
147
 
        Option("line", type=int, argname="lineno",
148
 
               help="jump to specified line number")
149
 
    ]
150
 
    aliases = ["gblame", "gpraise"]
151
 
    
152
 
    def run(self, filename, all=False, plain=False, line='1'):
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
 
        (wt, path) = WorkingTree.open_containing(filename)
172
 
        branch = wt.branch
173
 
 
174
 
        file_id = wt.path2id(path)
175
 
 
176
 
        if file_id is None:
177
 
            raise NotVersionedError(filename)
178
 
 
179
 
        window = GAnnotateWindow(all, plain)
180
 
        window.connect("destroy", lambda w: gtk.main_quit())
181
 
        window.set_title(path + " - gannotate")
182
 
        config = GAnnotateConfig(window)
183
 
        window.show()
184
 
        branch.lock_read()
185
 
        try:
186
 
            window.annotate(branch, file_id)
187
 
        finally:
188
 
            branch.unlock()
189
 
        window.jump_to_line(line)
190
 
        
191
 
        gtk.main()
192
 
 
193
 
register_command(cmd_gannotate)
194
 
 
195
 
class cmd_gcommit(Command):
196
 
    """GTK+ commit dialog
197
 
 
198
 
    Graphical user interface for committing revisions"""
199
 
    
200
 
    takes_args = []
201
 
    takes_options = []
202
 
 
203
 
    def run(self, filename=None):
204
 
        import pygtk
205
 
        pygtk.require("2.0")
206
 
 
207
 
        try:
208
 
            import gtk
209
 
        except RuntimeError, e:
210
 
            if str(e) == "could not open display":
211
 
                raise NoDisplayError
212
 
 
213
 
        from commit import GCommitDialog
214
 
        from bzrlib.commit import Commit
215
 
        from bzrlib.errors import (BzrCommandError, PointlessCommit, ConflictsInTree, 
216
 
           StrictCommitFailed)
217
 
 
218
 
        (wt, path) = WorkingTree.open_containing(filename)
219
 
        branch = wt.branch
220
 
 
221
 
        file_id = wt.path2id(path)
222
 
 
223
 
        if file_id is None:
224
 
            raise NotVersionedError(filename)
225
 
 
226
 
        dialog = GCommitDialog(wt)
227
 
        dialog.set_title(path + " - Commit")
228
 
        if dialog.run() != gtk.RESPONSE_CANCEL:
229
 
            Commit().commit(working_tree=wt,message=dialog.message,
230
 
                specific_files=dialog.specific_files)
231
 
 
232
 
register_command(cmd_gcommit)
233
 
 
234
 
class NoDisplayError(BzrCommandError):
235
 
    """gtk could not find a proper display"""
236
 
 
237
 
    def __str__(self):
238
 
        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 import (
 
57
    branch,
 
58
    config,
 
59
    )
 
60
from bzrlib.commands import plugin_cmds
 
61
 
 
62
from bzrlib.plugins.gtk.info import (
 
63
    bzr_plugin_version as version_info,
 
64
    bzr_compatible_versions,
 
65
    )
 
66
 
 
67
if version_info[3] == 'final':
 
68
    version_string = '%d.%d.%d' % version_info[:3]
 
69
else:
 
70
    version_string = '%d.%d.%d%s%d' % version_info
 
71
__version__ = version_string
 
72
 
 
73
bzrlib.api.require_any_api(bzrlib, bzr_compatible_versions)
 
74
 
 
75
if __name__ != 'bzrlib.plugins.gtk':
 
76
    from bzrlib.trace import warning
 
77
    warning("Not running as bzrlib.plugins.gtk, things may break.")
 
78
 
 
79
 
 
80
def set_ui_factory():
 
81
    from bzrlib.plugins.gtk.ui import GtkUIFactory
 
82
    import bzrlib.ui
 
83
    bzrlib.ui.ui_factory = GtkUIFactory()
 
84
 
 
85
 
 
86
def data_basedirs():
 
87
    return [os.path.dirname(__file__),
 
88
             "/usr/share/bzr-gtk", 
 
89
             "/usr/local/share/bzr-gtk"]
 
90
 
 
91
 
 
92
def data_path(*args):
 
93
    for basedir in data_basedirs():
 
94
        path = os.path.join(basedir, *args)
 
95
        if os.path.exists(path):
 
96
            return path
 
97
    return None
 
98
 
 
99
 
 
100
def icon_path(*args):
 
101
    return data_path(os.path.join('icons', *args))
 
102
 
 
103
 
 
104
commands = {
 
105
    "gannotate": ["gblame", "gpraise"],
 
106
    "gbranch": [],
 
107
    "gcheckout": [],
 
108
    "gcommit": ["gci"],
 
109
    "gconflicts": [],
 
110
    "gdiff": [],
 
111
    "ginit": [],
 
112
    "gmerge": [],
 
113
    "gmissing": [],
 
114
    "gpreferences": [],
 
115
    "gpush": [],
 
116
    "gsend": [],
 
117
    "gstatus": ["gst"],
 
118
    "gtags": [],
 
119
    "visualise": ["visualize", "vis", "viz", 'glog'],
 
120
    }
 
121
 
 
122
try:
 
123
    from bzrlib.plugins import loom
 
124
except ImportError:
 
125
    pass # Loom plugin doesn't appear to be present
 
126
else:
 
127
    commands["gloom"] = []
 
128
 
 
129
for cmd, aliases in commands.iteritems():
 
130
    plugin_cmds.register_lazy("cmd_%s" % cmd, aliases,
 
131
                              "bzrlib.plugins.gtk.commands")
 
132
 
 
133
def save_commit_messages(*args):
 
134
    from bzrlib.plugins.gtk import commitmsgs
 
135
    commitmsgs.save_commit_messages(*args)
 
136
 
 
137
branch.Branch.hooks.install_named_hook('post_uncommit',
 
138
                                       save_commit_messages,
 
139
                                       "Saving commit messages for gcommit")
 
140
 
 
141
option_registry = getattr(config, "option_registry", None)
 
142
if option_registry is not None:
 
143
    config.option_registry.register_lazy('nautilus_integration',
 
144
            'bzrlib.plugins.gtk.config', 'opt_nautilus_integration')
 
145
 
 
146
def load_tests(basic_tests, module, loader):
 
147
    testmod_names = [
 
148
        'tests',
 
149
        ]
 
150
    import sys
 
151
    default_encoding = sys.getdefaultencoding()
 
152
    try:
 
153
        result = basic_tests
 
154
        try:
 
155
            import gi.repository.Gtk
 
156
        except ImportError:
 
157
            return basic_tests
 
158
        basic_tests.addTest(loader.loadTestsFromModuleNames(
 
159
                ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
 
160
    finally:
 
161
        if sys.getdefaultencoding() != default_encoding:
 
162
            reload(sys)
 
163
            sys.setdefaultencoding(default_encoding)
 
164
    return basic_tests
 
165