/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-09-05 02:17:19 UTC
  • Revision ID: jelmer@samba.org-20060905021719-90e2eda34c41604b
Handle empty files more gracefully. Fixes #58951.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
 
1
#!/usr/bin/python
 
2
 
1
3
# This program is free software; you can redistribute it and/or modify
2
4
# it under the terms of the GNU General Public License as published by
3
5
# the Free Software Foundation; either version 2 of the License, or
12
14
# along with this program; if not, write to the Free Software
13
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
14
16
 
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
 
ginfo             GTK+ branch info dialog
26
 
gloom             GTK+ loom browse dialog
27
 
gmerge            GTK+ merge dialog
28
 
gmissing          GTK+ missing revisions dialog. 
29
 
gpreferences      GTK+ preferences dialog. 
30
 
gpush             GTK+ push.
31
 
gsend             GTK+ send merge directive.
32
 
gstatus           GTK+ status dialog.
33
 
gtags             Manage branch tags.
34
 
visualise         Graphically visualise this branch. 
35
 
"""
36
 
 
37
 
import os
38
 
import sys
39
 
 
40
 
if getattr(sys, "frozen", None) is not None: # we run bzr.exe
41
 
 
42
 
    # FIXME: Unless a better packaging solution is found, the following
43
 
    # provides a workaround for https://bugs.launchpad.net/bzr/+bug/388790 Also
44
 
    # see https://code.edge.launchpad.net/~vila/bzr-gtk/388790-windows-setup
45
 
    # for more details about while it's needed.
46
 
 
47
 
    # NOTE: _lib must be ahead of bzrlib or sax.saxutils (in olive) fails
48
 
    here = os.path.dirname(__file__)
49
 
    sys.path.insert(0, os.path.join(here, '_lib'))
50
 
    sys.path.append(os.path.join(here, '_lib/gtk-2.0'))
51
 
 
52
 
 
53
 
import bzrlib
54
 
import bzrlib.api
55
 
from bzrlib import (
56
 
    branch,
57
 
    config,
58
 
    errors,
59
 
    )
60
 
from bzrlib.commands import plugin_cmds
61
 
 
62
 
 
63
 
version_info = (0, 99, 0, 'dev', 1)
64
 
 
65
 
if version_info[3] == 'final':
66
 
    version_string = '%d.%d.%d' % version_info[:3]
67
 
else:
68
 
    version_string = '%d.%d.%d%s%d' % version_info
69
 
__version__ = version_string
70
 
 
71
 
COMPATIBLE_BZR_VERSIONS = [(1, 6, 0), (1, 7, 0), (1, 8, 0), (1, 9, 0),
72
 
                           (1, 10, 0), (1, 11, 0), (1, 12, 0), (1, 13, 0),
73
 
                           (1, 15, 0),
74
 
                           (1, 17, 0),
75
 
                           (2, 1, 0),
76
 
                           (2, 2, 0),
77
 
                           ]
78
 
 
79
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
80
 
 
81
 
if __name__ != 'bzrlib.plugins.gtk':
82
 
    from bzrlib.trace import warning
83
 
    warning("Not running as bzrlib.plugins.gtk, things may break.")
84
 
 
85
 
def import_pygtk():
86
 
    try:
 
17
"""GTK+ frontends to Bazaar commands """
 
18
 
 
19
from bzrlib.commands import Command, register_command, display_command
 
20
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
 
21
from bzrlib.commands import Command, register_command
 
22
from bzrlib.option import Option
 
23
from bzrlib.branch import Branch
 
24
from bzrlib.workingtree import WorkingTree
 
25
from bzrlib.bzrdir import BzrDir
 
26
 
 
27
__version__ = '0.10.0'
 
28
 
 
29
class cmd_gbranch(Command):
 
30
    """GTK+ branching.
 
31
    
 
32
    """
 
33
 
 
34
    def run(self):
87
35
        import pygtk
88
 
    except ImportError:
89
 
        raise errors.BzrCommandError("PyGTK not installed.")
90
 
    pygtk.require('2.0')
91
 
    return pygtk
92
 
 
93
 
 
94
 
def set_ui_factory():
95
 
    import_pygtk()
96
 
    from ui import GtkUIFactory
97
 
    import bzrlib.ui
98
 
    bzrlib.ui.ui_factory = GtkUIFactory()
99
 
 
100
 
 
101
 
def data_basedirs():
102
 
    return [os.path.dirname(__file__),
103
 
             "/usr/share/bzr-gtk", 
104
 
             "/usr/local/share/bzr-gtk"]
105
 
 
106
 
 
107
 
def data_path(*args):
108
 
    for basedir in data_basedirs():
109
 
        path = os.path.join(basedir, *args)
110
 
        if os.path.exists(path):
111
 
            return path
112
 
    return None
113
 
 
114
 
 
115
 
def icon_path(*args):
116
 
    return data_path(os.path.join('icons', *args))
117
 
 
118
 
 
119
 
def open_display():
120
 
    pygtk = import_pygtk()
121
 
    try:
 
36
        pygtk.require("2.0")
 
37
        try:
 
38
            import gtk
 
39
        except RuntimeError, e:
 
40
            if str(e) == "could not open display":
 
41
                raise NoDisplayError
 
42
 
 
43
        from clone import CloneDialog
 
44
 
 
45
        window = CloneDialog()
 
46
        if window.run() == gtk.RESPONSE_OK:
 
47
            bzrdir = BzrDir.open(window.url)
 
48
            bzrdir.sprout(window.dest_path)
 
49
 
 
50
register_command(cmd_gbranch)
 
51
 
 
52
class cmd_gdiff(Command):
 
53
    """Show differences in working tree in a GTK+ Window.
 
54
    
 
55
    Otherwise, all changes for the tree are listed.
 
56
    """
 
57
    takes_args = ['filename?']
 
58
    takes_options = ['revision']
 
59
 
 
60
    @display_command
 
61
    def run(self, revision=None, filename=None):
 
62
        wt = WorkingTree.open_containing(".")[0]
 
63
        branch = wt.branch
 
64
        if revision is not None:
 
65
            if len(revision) == 1:
 
66
                tree1 = wt
 
67
                revision_id = revision[0].in_history(branch).rev_id
 
68
                tree2 = branch.repository.revision_tree(revision_id)
 
69
            elif len(revision) == 2:
 
70
                revision_id_0 = revision[0].in_history(branch).rev_id
 
71
                tree2 = branch.repository.revision_tree(revision_id_0)
 
72
                revision_id_1 = revision[1].in_history(branch).rev_id
 
73
                tree1 = branch.repository.revision_tree(revision_id_1)
 
74
        else:
 
75
            tree1 = wt
 
76
            tree2 = tree1.basis_tree()
 
77
 
 
78
        from bzrlib.plugins.gtk.viz.diffwin import DiffWindow
122
79
        import gtk
123
 
    except RuntimeError, e:
124
 
        if str(e) == "could not open display":
125
 
            raise NoDisplayError
126
 
    set_ui_factory()
127
 
    return gtk
128
 
 
129
 
 
130
 
commands = {
131
 
    "gannotate": ["gblame", "gpraise"],
132
 
    "gbranch": [],
133
 
    "gcheckout": [],
134
 
    "gcommit": ["gci"],
135
 
    "gconflicts": [],
136
 
    "gdiff": [],
137
 
    "ginit": [],
138
 
    "ginfo": [],
139
 
    "gmerge": [],
140
 
    "gmissing": [],
141
 
    "gpreferences": [],
142
 
    "gpush": [],
143
 
    "gselftest": [],
144
 
    "gsend": [],
145
 
    "gstatus": ["gst"],
146
 
    "gtags": [],
147
 
    "visualise": ["visualize", "vis", "viz", 'glog'],
148
 
    }
149
 
 
150
 
try:
151
 
    from bzrlib.plugins import loom
152
 
except ImportError:
153
 
    pass # Loom plugin doesn't appear to be present
154
 
else:
155
 
    commands["gloom"] = []
156
 
 
157
 
for cmd, aliases in commands.iteritems():
158
 
    plugin_cmds.register_lazy("cmd_%s" % cmd, aliases,
159
 
                              "bzrlib.plugins.gtk.commands")
160
 
 
161
 
def save_commit_messages(*args):
162
 
    from bzrlib.plugins.gtk import commit
163
 
    commit.save_commit_messages(*args)
164
 
 
165
 
branch.Branch.hooks.install_named_hook('post_uncommit',
166
 
                                       save_commit_messages,
167
 
                                       "Saving commit messages for gcommit")
168
 
 
169
 
import gettext
170
 
gettext.install('olive-gtk')
171
 
 
172
 
# Let's create a specialized alias to protect '_' from being erased by other
173
 
# uses of '_' as an anonymous variable (think pdb for one).
174
 
_i18n = gettext.gettext
175
 
 
176
 
class NoDisplayError(errors.BzrCommandError):
 
80
        window = DiffWindow()
 
81
        window.connect("destroy", lambda w: gtk.main_quit())
 
82
        window.set_diff("Working Tree", tree1, tree2)
 
83
        if filename is not None:
 
84
            tree_filename = tree1.relpath(filename)
 
85
            try:
 
86
                window.set_file(tree_filename)
 
87
            except NoSuchFile:
 
88
                if (tree1.inventory.path2id(tree_filename) is None and 
 
89
                    tree2.inventory.path2id(tree_filename) is None):
 
90
                    raise NotVersionedError(filename)
 
91
                raise BzrCommandError('No changes found for file "%s"' % 
 
92
                                      filename)
 
93
        window.show()
 
94
 
 
95
        gtk.main()
 
96
 
 
97
register_command(cmd_gdiff)
 
98
 
 
99
class cmd_visualise(Command):
 
100
    """Graphically visualise this branch.
 
101
 
 
102
    Opens a graphical window to allow you to see the history of the branch
 
103
    and relationships between revisions in a visual manner,
 
104
 
 
105
    The default starting point is latest revision on the branch, you can
 
106
    specify a starting point with -r revision.
 
107
    """
 
108
    takes_options = [
 
109
        "revision",
 
110
        Option('limit', "maximum number of revisions to display",
 
111
               int, 'count')]
 
112
    takes_args = [ "location?" ]
 
113
    aliases = [ "visualize", "vis", "viz" ]
 
114
 
 
115
    def run(self, location=".", revision=None, limit=None):
 
116
        (branch, path) = Branch.open_containing(location)
 
117
        branch.lock_read()
 
118
        branch.repository.lock_read()
 
119
        try:
 
120
            if revision is None:
 
121
                revid = branch.last_revision()
 
122
                if revid is None:
 
123
                    return
 
124
            else:
 
125
                (revno, revid) = revision[0].in_history(branch)
 
126
 
 
127
            from viz.bzrkapp import BzrkApp
 
128
                
 
129
            app = BzrkApp()
 
130
            app.show(branch, revid, limit)
 
131
        finally:
 
132
            branch.repository.unlock()
 
133
            branch.unlock()
 
134
        app.main()
 
135
 
 
136
 
 
137
register_command(cmd_visualise)
 
138
 
 
139
class cmd_gannotate(Command):
 
140
    """GTK+ annotate.
 
141
    
 
142
    Browse changes to FILENAME line by line in a GTK+ window.
 
143
    """
 
144
 
 
145
    takes_args = ["filename", "line?"]
 
146
    takes_options = [
 
147
        Option("all", help="show annotations on all lines"),
 
148
        Option("plain", help="don't highlight annotation lines"),
 
149
        Option("line", type=int, argname="lineno",
 
150
               help="jump to specified line number")
 
151
    ]
 
152
    aliases = ["gblame", "gpraise"]
 
153
    
 
154
    def run(self, filename, all=False, plain=False, line='1'):
 
155
        import pygtk
 
156
        pygtk.require("2.0")
 
157
 
 
158
        try:
 
159
            import gtk
 
160
        except RuntimeError, e:
 
161
            if str(e) == "could not open display":
 
162
                raise NoDisplayError
 
163
 
 
164
        try:
 
165
            line = int(line)
 
166
        except ValueError:
 
167
            raise BzrCommandError('Line argument ("%s") is not a number.' % 
 
168
                                  line)
 
169
 
 
170
        from annotate.gannotate import GAnnotateWindow
 
171
        from annotate.config import GAnnotateConfig
 
172
 
 
173
        (wt, path) = WorkingTree.open_containing(filename)
 
174
        branch = wt.branch
 
175
 
 
176
        file_id = wt.path2id(path)
 
177
 
 
178
        if file_id is None:
 
179
            raise NotVersionedError(filename)
 
180
 
 
181
        window = GAnnotateWindow(all, plain)
 
182
        window.connect("destroy", lambda w: gtk.main_quit())
 
183
        window.set_title(path + " - gannotate")
 
184
        config = GAnnotateConfig(window)
 
185
        window.show()
 
186
        branch.lock_read()
 
187
        try:
 
188
            window.annotate(branch, file_id)
 
189
        finally:
 
190
            branch.unlock()
 
191
        window.jump_to_line(line)
 
192
        
 
193
        gtk.main()
 
194
 
 
195
register_command(cmd_gannotate)
 
196
 
 
197
class cmd_gcommit(Command):
 
198
    """GTK+ commit dialog
 
199
 
 
200
    Graphical user interface for committing revisions"""
 
201
    
 
202
    takes_args = []
 
203
    takes_options = []
 
204
 
 
205
    def run(self, filename=None):
 
206
        import pygtk
 
207
        pygtk.require("2.0")
 
208
 
 
209
        try:
 
210
            import gtk
 
211
        except RuntimeError, e:
 
212
            if str(e) == "could not open display":
 
213
                raise NoDisplayError
 
214
 
 
215
        from commit import GCommitDialog
 
216
        from bzrlib.commit import Commit
 
217
        from bzrlib.errors import (BzrCommandError, PointlessCommit, ConflictsInTree, 
 
218
           StrictCommitFailed)
 
219
 
 
220
        (wt, path) = WorkingTree.open_containing(filename)
 
221
        branch = wt.branch
 
222
 
 
223
        file_id = wt.path2id(path)
 
224
 
 
225
        if file_id is None:
 
226
            raise NotVersionedError(filename)
 
227
 
 
228
        dialog = GCommitDialog(wt)
 
229
        dialog.set_title(path + " - Commit")
 
230
        if dialog.run() != gtk.RESPONSE_CANCEL:
 
231
            Commit().commit(working_tree=wt,message=dialog.message,
 
232
                specific_files=dialog.specific_files)
 
233
 
 
234
register_command(cmd_gcommit)
 
235
 
 
236
class NoDisplayError(BzrCommandError):
177
237
    """gtk could not find a proper display"""
178
238
 
179
239
    def __str__(self):
180
 
        return "No DISPLAY. Unable to run GTK+ application."
181
 
 
182
 
 
183
 
credential_store_registry = getattr(config, "credential_store_registry", None)
184
 
if credential_store_registry is not None:
185
 
    try:
186
 
        credential_store_registry.register_lazy(
187
 
            "gnome-keyring", "bzrlib.plugins.gtk.keyring", "GnomeKeyringCredentialStore",
188
 
            help="The GNOME Keyring.", fallback=True)
189
 
    except TypeError:
190
 
    # Fallback credentials stores were introduced in Bazaar 1.15
191
 
        credential_store_registry.register_lazy(
192
 
            "gnome-keyring", "bzrlib.plugins.gtk.keyring", "GnomeKeyringCredentialStore",
193
 
            help="The GNOME Keyring.")
194
 
 
195
 
 
196
 
def load_tests(basic_tests, module, loader):
197
 
    testmod_names = [
198
 
        'tests',
199
 
        ]
200
 
    import sys
201
 
    default_encoding = sys.getdefaultencoding()
202
 
    try:
203
 
        result = basic_tests
204
 
        try:
205
 
            import_pygtk()
206
 
        except errors.BzrCommandError:
207
 
            return basic_tests
208
 
        basic_tests.addTest(loader.loadTestsFromModuleNames(
209
 
                ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
210
 
    finally:
211
 
        if sys.getdefaultencoding() != default_encoding:
212
 
            reload(sys)
213
 
            sys.setdefaultencoding(default_encoding)
214
 
    return basic_tests
 
240
        return "No DISPLAY. gannotate is disabled."