[bpt/coccinelle.git] / python / coccilib / coccigui / vimeditor.py

# -*- coding: utf-8 -*- 

# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
#Copyright (c) 2005-2006 The PIDA Project

#Permission is hereby granted, free of charge, to any person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitation the rights
#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#copies of the Software, and to permit persons to whom the Software is
#furnished to do so, subject to the following conditions:

#The above copyright notice and this permission notice shall be included in
#all copies or substantial portions of the Software.

#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
#SOFTWARE.

import os
import gobject

import pida.core.service as service
from pida.core import errors

defs = service.definitions
types = service.types

import vimcom

class vim_editor(object):

    single_view = None

    class display(defs.optiongroup):
        class colour_scheme(defs.option):
            """The colour scheme to use in vim (Empty will be ignored)."""
            rtype = types.string
            default = ''
        class hide_vim_menu(defs.option):
            """Whether the vim menu will be hidden."""
            rtype = types.boolean
            default = False

    def init(self):
        self.__servers = {}
        self.__documents = {}
        self.__old_shortcuts = {'n':{}, 'v':{}}
        self.__currentdocument = None
        self._create_initscript()
        self.__cw = vimcom.communication_window(self)
        self.__newdocs = {}

    def _create_initscript(self):
        script_path = os.path.join(self.boss.get_pida_home(), 'pida_vim_init.vim')
        if not os.path.exists(script_path):
            f = open(script_path, 'w')
            f.write(vimcom.VIMSCRIPT)
            f.close()

    def vim_init_server(self):
        self.__cw.load_script(self.server,
            os.path.join(self.boss.get_pida_home(), 'pida_vim_init.vim'))

    def stop_fetching_serverlist(self):
        self.__cw.keep_fetching_serverlist = False

    def get_server(self):
        raise NotImplementedError

    def vim_start(self):
        raise NotImplementedError

    def vim_new_serverlist(self, serverlist):
        raise NotImplementedError

    def cmd_start(self):
        self.vim_start()

    def cmd_revert(self):
        self.__cw.revert(self.server)

    def cmd_close(self, document):
        if document.unique_id in self.__newdocs:
            fn = self.__newdocs[document.unique_id]
        else:
            fn = document.filename
        self.__cw.close_buffer(self.server, fn)

    def cmd_edit(self, document):
        """Open and edit."""
        if document is not self.__currentdocument:
            if (document.unique_id in
                self.__servers.setdefault(self.server, [])):
                if document.unique_id in self.__newdocs:
                    fn = self.__newdocs[document.unique_id]
                else:
                    fn = document.filename
                self.__cw.change_buffer(self.server, fn)
                self.__cw.foreground(self.server)
            else:
                found = False
                for server in self.__servers:
                    serverdocs = self.__servers[server]
                    if document.unique_id in serverdocs:
                        self.__cw.change_buffer(server, document.filename)
                        self.__cw.foreground(server)
                        found = True
                        break
                if not found:
                    if document.filename is None:
                        newname = self.__cw.new_file(self.server)
                        self.__newdocs[document.unique_id] = newname
                    else:
                        self.__cw.open_file(self.server, document.filename)
                    self.__servers[self.server].append(document.unique_id)
                    self.__documents[document.unique_id] = document
            self.__currentdocument = document
        if self.single_view is not None:
            self.single_view.raise_page()
            if document.filename is None:
                title = 'New File'
            else:
                title = document.filename
            self.single_view.long_title = title

    def cmd_undo(self):
        self.__cw.undo(self.server)

    def cmd_redo(self):
        self.__cw.redo(self.server)

    def cmd_cut(self):
        self.__cw.cut(self.server)

    def cmd_copy(self):
        self.__cw.copy(self.server)

    def cmd_paste(self):
        self.__cw.paste(self.server)

    def cmd_save(self):
        self.__cw.save(self.server)

    def cmd_save_as(self, filename):
        del self.__newdocs[self.__currentdocument.unique_id]
        self.__cw.save_as(self.server, filename)

    def cmd_goto_line(self, linenumber):
        self.__cw.goto_line(self.server, linenumber + 1)

    def cmd_show_mark(self, index, filename, line):
        self.__cw.show_sign(self.server, index, filename, line)
    
    def cmd_hide_mark(self, index):
        pass

    def reset(self):
        colorscheme = self.opts.display__colour_scheme
        if colorscheme:
            self.__cw.set_colorscheme(self.server, colorscheme)
        if self.opts.display__hide_vim_menu:
            self.__cw.set_menu_visible(self.server, False)
            #self.__load_shortcuts()

    def open_file_line(self, filename, linenumber):
        if self.__currentfile != filename:
            self.open_file(filename)
            self.__bufferevents.append([self.goto_line, (linenumber, )])
        else:
            self.goto_line(linenumber)

    def goto_line(self, linenumber):
        self.__cw.change_cursor(self.server, 1, linenumber)

    def vim_bufferchange(self, server, cwd, filename, bufnr):
        self.log.debug('vim buffer change "%s"', filename)
        if not filename or filename in '-MiniBufExplorer-':
            return
        if os.path.abspath(filename) != filename:
            filename = os.path.join(cwd, filename)
        if os.path.isdir(filename):
            if self.opts.behaviour__open_directories_in_pida:
                self.boss.call_command('filemanager', 'browse',
                    directory=filename)
                self.__cw.close_buffer(self.server, filename)
            return
        if self.__currentdocument is None or filename != self.__currentdocument.filename:
            for uid, fn in self.__newdocs.iteritems():
                if fn == filename:
                    doc = self.__documents[uid]
                    self.__current_doc_set(doc)
                    return
            for doc in self.__documents.values():
                if doc.filename == filename:
                    self.__current_doc_set(doc)
                    return
            self.boss.call_command('buffermanager', 'open_file',
                                    filename=filename)

    def __current_doc_set(self, doc):
        self.__currentdocument = doc
        self.boss.call_command('buffermanager', 'open_document',
                                document=doc)

    def vim_bufferunload(self, server, filename, *args):
        self.log.debug('vim unloaded "%s"', filename)
        if filename != '':
            doc = None
            for uid, fn in self.__newdocs.iteritems():
                if fn == filename:
                    doc = self.__documents[uid]
                    break
            if doc is None:
                for uid, document in self.__documents.iteritems():
                    if document.filename == filename:
                        doc = document
                        break
            if doc is not None:
                self.__servers[server].remove(doc.unique_id)
                del self.__documents[uid]
                self.__currentdocument = None
                self.boss.call_command('buffermanager', 'document_closed',
                                            document=doc, dorefresh=True)

    def vim_started(self, server):
        print 'started'

    def vim_filesave(self, server, *args):
        self.boss.call_command('buffermanager', 'reset_current_document')

    def vim_globalkp(self, server, name):
        self.boss.command('keyboardshortcuts', 'keypress-by-name',
                           kpname=name)

    def vim_shutdown(self, server, *args):
        #self.clean_after_shutdown(server)
        self.after_shutdown(server)

    def vim_set_breakpoint(self, server, line):
        self.boss.call_command('pythondebugger', 'set_breakpoint',
            filename=self.__currentdocument.filename, line=int(line))

    def clean_after_shutdown(self, server):
        for docid in self.__servers.setdefault(server, []):
            doc = self.__documents[docid]
            del self.__documents[docid]
            self.boss.call_command('buffermanager', 'document_closed',
                                    document=doc)
        self.__servers[server] = []
        self.__currentdocument = None

    def after_shutdown(self, server):
        pass

    def get_vim_window(self):
        return self.__cw
    vim_window= property(get_vim_window)

    def get_current_document(self):
        return self.__currentdocument
    current_document = property(get_current_document)

    def stop(self):
        self.__cw.quit(self.server)
Commit	Line	Data
34e49164 C	1	# -- coding: utf-8 --
	2
	3	# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
	4	#Copyright (c) 2005-2006 The PIDA Project
	5
	6	#Permission is hereby granted, free of charge, to any person obtaining a copy
	7	#of this software and associated documentation files (the "Software"), to deal
	8	#in the Software without restriction, including without limitation the rights
	9	#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	#copies of the Software, and to permit persons to whom the Software is
	11	#furnished to do so, subject to the following conditions:
	12
	13	#The above copyright notice and this permission notice shall be included in
	14	#all copies or substantial portions of the Software.
	15
	16	#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	19	#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	22	#SOFTWARE.
	23
	24	import os
	25	import gobject
	26
	27	import pida.core.service as service
	28	from pida.core import errors
	29
	30	defs = service.definitions
	31	types = service.types
	32
	33	import vimcom
	34
	35	class vim_editor(object):
	36
	37	single_view = None
	38
	39	class display(defs.optiongroup):
	40	class colour_scheme(defs.option):
	41	"""The colour scheme to use in vim (Empty will be ignored)."""
	42	rtype = types.string
	43	default = ''
	44	class hide_vim_menu(defs.option):
	45	"""Whether the vim menu will be hidden."""
	46	rtype = types.boolean
	47	default = False
	48
	49	def init(self):
	50	self.__servers = {}
	51	self.__documents = {}
	52	self.__old_shortcuts = {'n':{}, 'v':{}}
	53	self.__currentdocument = None
	54	self._create_initscript()
	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
71
72	def get_server(self):
73	raise NotImplementedError
74
75	def vim_start(self):
76	raise NotImplementedError
77
78	def vim_new_serverlist(self, serverlist):
79	raise NotImplementedError
80
81	def cmd_start(self):
82	self.vim_start()
83
84	def cmd_revert(self):
85	self.__cw.revert(self.server)
86
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)
93
94	def cmd_edit(self, document):
95	"""Open and edit."""
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)
104	self.__cw.foreground(self.server)
105	else:
106	found = False
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)
111	self.__cw.foreground(server)
112	found = True
113	break
114	if not found:
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
123	if self.single_view is not None:
124	self.single_view.raise_page()
125	if document.filename is None:
126	title = 'New File'
127	else:
128	title = document.filename
129	self.single_view.long_title = title
130
131	def cmd_undo(self):
132	self.__cw.undo(self.server)
133
134	def cmd_redo(self):
135	self.__cw.redo(self.server)
136
137	def cmd_cut(self):
138	self.__cw.cut(self.server)
139
140	def cmd_copy(self):
141	self.__cw.copy(self.server)
142
143	def cmd_paste(self):
144	self.__cw.paste(self.server)
145
146	def cmd_save(self):
147	self.__cw.save(self.server)
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
153	def cmd_goto_line(self, linenumber):
154	self.__cw.goto_line(self.server, linenumber + 1)
155
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
161
162	def reset(self):
163	colorscheme = self.opts.display__colour_scheme
164	if colorscheme:
165	self.__cw.set_colorscheme(self.server, colorscheme)
166	if self.opts.display__hide_vim_menu:
167	self.__cw.set_menu_visible(self.server, False)
168	#self.__load_shortcuts()
169
170	def open_file_line(self, filename, linenumber):
171	if self.__currentfile != filename:
172	self.open_file(filename)
173	self.__bufferevents.append([self.goto_line, (linenumber, )])
174	else:
175	self.goto_line(linenumber)
176
177	def goto_line(self, linenumber):
178	self.__cw.change_cursor(self.server, 1, linenumber)
179
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-':
183	return
184	if os.path.abspath(filename) != filename:
185	filename = os.path.join(cwd, 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
202	self.boss.call_command('buffermanager', 'open_file',
203	filename=filename)
204
205	def __current_doc_set(self, doc):
206	self.__currentdocument = doc
207	self.boss.call_command('buffermanager', 'open_document',
208	document=doc)
209
210	def vim_bufferunload(self, server, filename, *args):
211	self.log.debug('vim unloaded "%s"', filename)
212	if 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'
232
233	def vim_filesave(self, server, *args):
234	self.boss.call_command('buffermanager', 'reset_current_document')
235
236	def vim_globalkp(self, server, name):
237	self.boss.command('keyboardshortcuts', 'keypress-by-name',
238	kpname=name)
239
240	def vim_shutdown(self, server, *args):
241	#self.clean_after_shutdown(server)
242	self.after_shutdown(server)
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
248	def clean_after_shutdown(self, server):
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
256
257	def after_shutdown(self, server):
258	pass
259
260	def get_vim_window(self):
261	return self.__cw
262	vim_window= property(get_vim_window)
263
264	def get_current_document(self):
265	return self.__currentdocument
266	current_document = property(get_current_document)
267
268	def stop(self):
269	self.__cw.quit(self.server)