← Back to branch summary

~ubuntu-branches/ubuntu/precise/pida/precise

« back to all changes in this revision

Viewing changes to pida/utils/vim/vimeditor.py

  • Committer: Bazaar Package Importer
  • Author(s): Jan Luebbe
  • Date: 2007-04-17 16:08:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20070417160806-3ttlb6igf94x9i03
Tags: 0.4.4-1
http://bugs.debian.org/419129
http://bugs.debian.org/418716
* New upstream release (closes: #419129)
* Add dependency on python-glade2 (closes: #418716)
* Update copyright

Show diffs side-by-side

added added

removed removed

Lines of Context:
pida/utils/vim/vimeditor.py
22
22
#SOFTWARE.
23
23
 
24
24
import os
 
25
import gobject
25
26
 
26
27
import pida.core.service as service
27
28
from pida.core import errors
33
34
 
34
35
class vim_editor(object):
35
36
 
 
37
    single_view = None
 
38
 
36
39
    class display(defs.optiongroup):
37
40
        class colour_scheme(defs.option):
38
41
            """The colour scheme to use in vim (Empty will be ignored)."""
44
47
            default = False
45
48
 
46
49
    def init(self):
47
 
        self.__files = {}
 
50
        self.__servers = {}
 
51
        self.__documents = {}
48
52
        self.__old_shortcuts = {'n':{}, 'v':{}}
49
 
        self.__currentfile = None
 
53
        self.__currentdocument = None
 
54
        self._create_initscript()
50
55
        self.__cw = vimcom.communication_window(self)
 
56
        self.__newdocs = {}
 
57
 
 
58
    def _create_initscript(self):
 
59
        script_path = os.path.join(self.boss.get_pida_home(), 'pida_vim_init.vim')
 
60
        if not os.path.exists(script_path):
 
61
            f = open(script_path, 'w')
 
62
            f.write(vimcom.VIMSCRIPT)
 
63
            f.close()
 
64
 
 
65
    def vim_init_server(self):
 
66
        self.__cw.load_script(self.server,
 
67
            os.path.join(self.boss.get_pida_home(), 'pida_vim_init.vim'))
 
68
 
 
69
    def stop_fetching_serverlist(self):
 
70
        self.__cw.keep_fetching_serverlist = False
51
71
 
52
72
    def get_server(self):
53
73
        raise NotImplementedError
54
74
 
55
 
    def start(self):
 
75
    def vim_start(self):
56
76
        raise NotImplementedError
57
77
 
58
78
    def vim_new_serverlist(self, serverlist):
59
79
        raise NotImplementedError
60
80
 
61
81
    def cmd_start(self):
62
 
        self.start()
 
82
        self.vim_start()
63
83
 
64
84
    def cmd_revert(self):
65
85
        self.__cw.revert(self.server)
66
86
 
67
 
    def cmd_close(self, filename):
68
 
        self.__cw.close_buffer(self.server, filename)
 
87
    def cmd_close(self, document):
 
88
        if document.unique_id in self.__newdocs:
 
89
            fn = self.__newdocs[document.unique_id]
 
90
        else:
 
91
            fn = document.filename
 
92
        self.__cw.close_buffer(self.server, fn)
69
93
 
70
 
    def cmd_edit(self, filename):
 
94
    def cmd_edit(self, document):
71
95
        """Open and edit."""
72
 
        self.boss.call_command('documenttypes',
73
 
                               'disable_document_accelerators')
74
 
        if filename != self.__currentfile:
75
 
            if filename in self.__files.setdefault(self.server, []):
76
 
                self.__cw.change_buffer(self.server, filename)
 
96
        if document is not self.__currentdocument:
 
97
            if (document.unique_id in
 
98
                self.__servers.setdefault(self.server, [])):
 
99
                if document.unique_id in self.__newdocs:
 
100
                    fn = self.__newdocs[document.unique_id]
 
101
                else:
 
102
                    fn = document.filename
 
103
                self.__cw.change_buffer(self.server, fn)
77
104
                self.__cw.foreground(self.server)
78
105
            else:
79
106
                found = False
80
 
                for server in self.__files:
81
 
                    serverfiles = self.__files[server]
82
 
                    if filename in serverfiles:
83
 
                        self.__cw.change_buffer(server, filename)
 
107
                for server in self.__servers:
 
108
                    serverdocs = self.__servers[server]
 
109
                    if document.unique_id in serverdocs:
 
110
                        self.__cw.change_buffer(server, document.filename)
84
111
                        self.__cw.foreground(server)
85
112
                        found = True
86
113
                        break
87
114
                if not found:
88
 
                    self.__cw.open_file(self.server, filename)
89
 
                    self.__files[self.server].append(filename)
90
 
            self.__currentfile = filename
 
115
                    if document.filename is None:
 
116
                        newname = self.__cw.new_file(self.server)
 
117
                        self.__newdocs[document.unique_id] = newname
 
118
                    else:
 
119
                        self.__cw.open_file(self.server, document.filename)
 
120
                    self.__servers[self.server].append(document.unique_id)
 
121
                    self.__documents[document.unique_id] = document
 
122
            self.__currentdocument = document
91
123
        if self.single_view is not None:
92
124
            self.single_view.raise_page()
93
 
            self.single_view.long_title = filename
 
125
            if document.filename is None:
 
126
                title = 'New File'
 
127
            else:
 
128
                title = document.filename
 
129
            self.single_view.long_title = title
94
130
 
95
131
    def cmd_undo(self):
96
132
        self.__cw.undo(self.server)
110
146
    def cmd_save(self):
111
147
        self.__cw.save(self.server)
112
148
 
 
149
    def cmd_save_as(self, filename):
 
150
        del self.__newdocs[self.__currentdocument.unique_id]
 
151
        self.__cw.save_as(self.server, filename)
 
152
 
113
153
    def cmd_goto_line(self, linenumber):
114
 
        self.__cw.goto_line(self.server, linenumber)
 
154
        self.__cw.goto_line(self.server, linenumber + 1)
115
155
 
116
 
    def __load_shortcuts(self):
117
 
        for mapc in ['n']:
118
 
            if self.__old_shortcuts[mapc].setdefault(self.server, []):
119
 
                for sc in self.__old_shortcuts[mapc][self.server]:
120
 
                    self.__cw.send_ex(self.server, UNMAP_COM % (mapc, sc))
121
 
            self.__old_shortcuts[mapc][self.server] = []
122
 
            #l = self.options.get('shortcut-leader').value
123
 
            globalkpsopts = self.boss.option_group('keyboardshortcuts')
124
 
            globalkps = []
125
 
            for opt in globalkpsopts:
126
 
                vals = opt.value().split()
127
 
                if len(vals) == 2:
128
 
                    mod, k = vals
129
 
                v = '<lt>%s-%s>' % (mod, k)
130
 
                globalkps.append((v, '''Async_event("globalkp,%s")''' %
131
 
                                  opt.value().replace('\\', '\\\\')))
132
 
            def load():
133
 
                for c, command in globalkps:
134
 
                    try:
135
 
                        #c = self.options.get(name).value()
136
 
                        sc = ''.join([l, c])
137
 
                        self.__old_shortcuts[mapc][self.server].append(sc)
138
 
                        self.__cw.send_ex(self.server, NMAP_COM % (mapc, c, command))
139
 
                    except errors.BadRegistryKeyError:
140
 
                        pass
141
 
            gobject.timeout_add(200, load)
 
156
    def cmd_show_mark(self, index, filename, line):
 
157
        self.__cw.show_sign(self.server, index, filename, line)
 
158
    
 
159
    def cmd_hide_mark(self, index):
 
160
        pass
142
161
 
143
162
    def reset(self):
144
 
        colorscheme = self.opt('display', 'colour_scheme')
 
163
        colorscheme = self.opts.display__colour_scheme
145
164
        if colorscheme:
146
165
            self.__cw.set_colorscheme(self.server, colorscheme)
147
 
        if self.opt('display', 'hide_vim_menu'):
 
166
        if self.opts.display__hide_vim_menu:
148
167
            self.__cw.set_menu_visible(self.server, False)
149
168
            #self.__load_shortcuts()
150
169
 
158
177
    def goto_line(self, linenumber):
159
178
        self.__cw.change_cursor(self.server, 1, linenumber)
160
179
 
161
 
    def vim_bufferchange(self, server, cwd, filename):
162
 
        if not filename:
 
180
    def vim_bufferchange(self, server, cwd, filename, bufnr):
 
181
        self.log.debug('vim buffer change "%s"', filename)
 
182
        if not filename or filename in '-MiniBufExplorer-':
163
183
            return
164
184
        if os.path.abspath(filename) != filename:
165
185
            filename = os.path.join(cwd, filename)
166
 
        self.log.debug('vim buffer change "%s"', filename)
167
 
        if filename != self.__currentfile:
168
 
            self.__currentfile = filename
169
 
            if filename not in self.__files.setdefault(server, []):
170
 
                self.__files[server].append(filename)
 
186
        if os.path.isdir(filename):
 
187
            if self.opts.behaviour__open_directories_in_pida:
 
188
                self.boss.call_command('filemanager', 'browse',
 
189
                    directory=filename)
 
190
                self.__cw.close_buffer(self.server, filename)
 
191
            return
 
192
        if self.__currentdocument is None or filename != self.__currentdocument.filename:
 
193
            for uid, fn in self.__newdocs.iteritems():
 
194
                if fn == filename:
 
195
                    doc = self.__documents[uid]
 
196
                    self.__current_doc_set(doc)
 
197
                    return
 
198
            for doc in self.__documents.values():
 
199
                if doc.filename == filename:
 
200
                    self.__current_doc_set(doc)
 
201
                    return
171
202
            self.boss.call_command('buffermanager', 'open_file',
172
203
                                    filename=filename)
173
204
 
 
205
    def __current_doc_set(self, doc):
 
206
        self.__currentdocument = doc
 
207
        self.boss.call_command('buffermanager', 'open_document',
 
208
                                document=doc)
 
209
 
174
210
    def vim_bufferunload(self, server, filename, *args):
175
211
        self.log.debug('vim unloaded "%s"', filename)
176
212
        if filename != '':
177
 
            # unloaded an empty new file
178
 
            if filename in self.__files.setdefault(server, []):
179
 
                self.__files[server].remove(filename)
180
 
                self.boss.call_command('buffermanager', 'file_closed',
181
 
                                        filename=filename)
182
 
                self.__currentfile = None
183
 
            else:
184
 
                self.log.info('vim unloaded an unknown file %s', filename)
 
213
            doc = None
 
214
            for uid, fn in self.__newdocs.iteritems():
 
215
                if fn == filename:
 
216
                    doc = self.__documents[uid]
 
217
                    break
 
218
            if doc is None:
 
219
                for uid, document in self.__documents.iteritems():
 
220
                    if document.filename == filename:
 
221
                        doc = document
 
222
                        break
 
223
            if doc is not None:
 
224
                self.__servers[server].remove(doc.unique_id)
 
225
                del self.__documents[uid]
 
226
                self.__currentdocument = None
 
227
                self.boss.call_command('buffermanager', 'document_closed',
 
228
                                            document=doc, dorefresh=True)
 
229
 
 
230
    def vim_started(self, server):
 
231
        print 'started'
185
232
 
186
233
    def vim_filesave(self, server, *args):
187
234
        self.boss.call_command('buffermanager', 'reset_current_document')
191
238
                           kpname=name)
192
239
 
193
240
    def vim_shutdown(self, server, *args):
194
 
        self.clean_after_shutdown(server)
 
241
        #self.clean_after_shutdown(server)
195
242
        self.after_shutdown(server)
196
243
 
 
244
    def vim_set_breakpoint(self, server, line):
 
245
        self.boss.call_command('pythondebugger', 'set_breakpoint',
 
246
            filename=self.__currentdocument.filename, line=int(line))
 
247
 
197
248
    def clean_after_shutdown(self, server):
198
 
        for filename in self.__files.setdefault(server, []):
199
 
            self.boss.call_command('buffermanager', 'file_closed',
200
 
                                    filename=filename)
201
 
        self.__files = {}
202
 
        self.__currentfile = None
 
249
        for docid in self.__servers.setdefault(server, []):
 
250
            doc = self.__documents[docid]
 
251
            del self.__documents[docid]
 
252
            self.boss.call_command('buffermanager', 'document_closed',
 
253
                                    document=doc)
 
254
        self.__servers[server] = []
 
255
        self.__currentdocument = None
203
256
 
204
257
    def after_shutdown(self, server):
205
258
        pass
208
261
        return self.__cw
209
262
    vim_window= property(get_vim_window)
210
263
 
211
 
    def get_current_file(self):
212
 
        return self.__currentfile
213
 
    current_file = property(get_current_file)
 
264
    def get_current_document(self):
 
265
        return self.__currentdocument
 
266
    current_document = property(get_current_document)
214
267
 
 
268
    def stop(self):
 
269
        self.__cw.quit(self.server)