Commit 02154f94bd08ed42442d88e885c910c0cf2a3b9d

Daniel Francis <santiago.danielfrancis @gm…l.com>
Tue Dec 20 10:36:09 EST 2011

Tree SHA1: b70ef6a
Parent SHA1: 678210e (Add a python console and a button for hide and show the console. Also added a module view_changes but is inactive)
raw diff | raw patch

GObject signal handling implemented

Diff rendering mode:
inline
side by side


43	43	from sugar.activity import activity
44	44
45	45	from pep8_check import PEP8_Check
46		from font_options import FontToolbarButton
47		from editor import Editor, LANGUAGE_MANAGER, LANGUAGES
	46	import options
	47	from editor import Editor
48	48	from python_console import PythonConsole
49	49	import file_choosers
50		file_choosers.langsmanager = LANGUAGE_MANAGER
51		file_choosers.langs = LANGUAGES
	50	file_choosers.langsmanager = options.LANGUAGE_MANAGER
	51	file_choosers.langs = options.LANGUAGES
52	52
53	53
54	54	class JAMEdit(activity.Activity):
…	…
62	62
63	63	self.editor = Editor()
64	64	self.editor.connect("pep8-aviable", self.enable_pep8)
	65	self.editor.connect('language-changed', self.language_changed)
65	66
66	67	self.editor.set_size_request(800, 790)
67	68	scroll = gtk.ScrolledWindow()
…	…
72	72	scroll.show_all()
73	73
74	74	vbox = gtk.VBox()
75		vbox.pack_start(scroll, True, True, 0)
76		vbox.show_all()
	75	vpaned = gtk.VPaned()
	76	vpaned.pack1(scroll)
	77	vbox.pack_start(vpaned, True, True, 0)
77	78
78	79	self.set_canvas(vbox)
79	80
80	81	# **** Toolbars ****
81	82
82		self.toolbar_box = ToolbarBox()
83
84		activity_button = ActivityToolbarButton(self)
85		activity_toolbar = activity_button.page
86
87		# Abrir objeto / Open object
88		open_obj_btn = ToolButton("open-from-journal")
89		open_obj_btn.connect("clicked",
90		file_choosers.open_from_journal, None, self)
91		open_obj_btn.set_tooltip(_("Open object from journal"))
92		activity_toolbar.insert(open_obj_btn, -1)
93
94		# Separador / Separator
95		separator = gtk.SeparatorToolItem()
96		separator.set_draw(True)
97		separator.set_expand(False)
98		activity_toolbar.insert(separator, -1)
99
100		# **** Open File button ****
101		open_btn = ToolButton("fileopen")
102		open_btn.set_tooltip(_("Open File"))
103		open_btn.set_accelerator('<ctrl>o')
104		open_btn.connect("clicked", self.open_file)
105		activity_toolbar.insert(open_btn, -1)
106
107		# **** Save File button ****
108		save_btn = ToolButton("stock_save")
109		save_btn.set_tooltip(_("Save this file"))
110		save_btn.set_accelerator('<ctrl>s')
111		save_btn.connect("clicked", self.save_file)
112		activity_toolbar.insert(save_btn, -1)
113
114		activity_toolbar.show_all()
115		activity_toolbar.stop.hide()
116
117		# Guardar como / Save As
118		save_as = gtk.MenuItem(_("Save on the file system."))
119		activity_toolbar.keep.props.palette.menu.append(save_as)
120		save_as.connect("activate", self.save_file_as)
121		save_as.show()
122
123		# Nuevo / New
124		new = ToolButton("new")
125		new.set_tooltip(_("New file"))
126		new.set_accelerator('<ctrl>n')
127		new.connect("clicked", self.new)
128		activity_toolbar.insert(new, 6)
129		new.show()
130
131		activity_toolbar.keep.show()
132
133		self.toolbar_box.toolbar.insert(activity_button, 0)
134
135		# Edicion / Edit Toolbar
136
137		edit_toolbar = EditToolbar()
138		edit_toolbar_button = ToolbarButton(label=_("Edit"),
139		page=edit_toolbar,
140		icon_name='toolbar-edit')
141
142		edit_toolbar.cut = ToolButton("cut")
143		edit_toolbar.cut.set_tooltip(_("Cut"))
144		edit_toolbar.cut.set_accelerator('<ctrl>x')
145		edit_toolbar.insert(edit_toolbar.cut, 4)
146
147		separator = gtk.SeparatorToolItem()
148		separator.set_draw(False)
149		separator.set_expand(True)
150		edit_toolbar.insert(separator, -1)
151
152		edit_toolbar.pep8_btn = ToolButton('pep8')
153		edit_toolbar.pep8_btn.set_tooltip(_("PEP 8 Check"))
154		edit_toolbar.pep8_btn.connect("clicked", self.pep8_check)
155		edit_toolbar.insert(edit_toolbar.pep8_btn, -1)
156
157		edit_toolbar.pep8_datetime_separator = gtk.SeparatorToolItem()
158		edit_toolbar.pep8_datetime_separator.set_draw(True)
159		edit_toolbar.insert(edit_toolbar.pep8_datetime_separator, -1)
160
161		insert_datetime = ToolButton("insert-datetime")
162		insert_datetime.connect("clicked",
163		self.editor._insert_date_time)
164		insert_datetime.set_tooltip(_("Insert date and time"))
165		edit_toolbar.insert(insert_datetime, -1)
166		insert_datetime.show_all()
167
168		edit_toolbar.copy.connect("clicked", self.editor._copy_cb)
169		edit_toolbar.paste.connect("clicked", self.editor._paste_cb)
170		edit_toolbar.undo.connect("clicked", self.editor._undo_cb)
171		edit_toolbar.redo.connect("clicked", self.editor._redo_cb)
172		edit_toolbar.cut.connect("clicked", self.editor._cut_cb)
173
174		edit_toolbar.show_all()
175		edit_toolbar.pep8_btn.hide()
176		edit_toolbar.pep8_datetime_separator.set_draw(False)
177
178		self.toolbar_box.toolbar.insert(edit_toolbar_button, -1)
179
180		self.edit_toolbar = edit_toolbar
181
182		# Separador / Separator
183		separator = gtk.SeparatorToolItem()
184		separator.set_draw(False)
185		self.toolbar_box.toolbar.insert(separator, -1)
186
187		# Buscar / Search
188		search_entry = iconentry.IconEntry()
189		search_entry.set_size_request(gtk.gdk.screen_width() / 3, -1)
190		search_entry.set_icon_from_name(
191		iconentry.ICON_ENTRY_PRIMARY, 'system-search')
192		search_entry.add_clear_button()
193		search_entry.connect('activate',
194		self._search_entry_activate_cb)
195		search_entry.connect('changed',
196		self._search_entry_changed_cb)
197		search_item = gtk.ToolItem()
198		search_item.add(search_entry)
199		self.toolbox.toolbar.insert(search_item, -1)
200
201		self._search_prev = ToolButton('go-previous-paired')
202		self._search_prev.set_tooltip(_('Previous'))
203		self._search_prev.connect('clicked',
204		self.editor._search_prev_cb)
205		self.toolbox.toolbar.insert(self._search_prev, -1)
206
207		self._search_next = ToolButton('go-next-paired')
208		self._search_next.set_tooltip(_('Next'))
209		self._search_next.connect('clicked',
210		self.editor._search_next_cb)
211		self.toolbox.toolbar.insert(self._search_next, -1)
	83	self.toolbar_box = options.OptionWidget(self, self.editor.get_pango_context())
	84	self.toolbar_box.connect('open-from-journal', file_choosers.open_from_journal, None, self)
	85	self.toolbar_box.connect('open-file', self.open_file)
	86	self.toolbar_box.connect('save-file', self.save_file)
	87	self.toolbar_box.connect('save-as', self.save_file_as)
	88	self.toolbar_box.connect('new-file', self.new)
	89	self.toolbar_box.connect('pep8-check', self.pep8_check)
	90	self.toolbar_box.connect('insert-datetime', self.editor._insert_date_time)
	91	self.toolbar_box.connect('copy', self.editor._copy_cb)
	92	self.toolbar_box.connect('paste', self.editor._paste_cb)
	93	self.toolbar_box.connect('undo', self.editor._undo_cb)
	94	self.toolbar_box.connect('redo', self.editor._redo_cb)
	95	self.toolbar_box.connect('cut', self.editor._cut_cb)
	96	self.toolbar_box.connect('search-text', self._search_text)
	97	self.toolbar_box.connect('search-prev', self.editor._search_prev_cb)
	98	self.toolbar_box.connect('search-next', self.editor._search_next_cb)
	99	self.toolbar_box.connect('show-line-numbers', self.editor._set_show_line_numbers)
	100	self.toolbar_box.connect('language-changed', self.change_language)
	101	self.toolbar_box.connect('style-changed', self.change_style)
	102	self.toolbar_box.connect('font-changed', self.change_font)
	103	self.toolbar_box.show_all()
	104	self.set_toolbar_box(self.toolbar_box)
212	105
213	106	# Barra de estado de PEP8 / PEP8 status bar
214		self.pep8 = PEP8_Check(self)
	107	self.pep8 = PEP8_Check()
215	108
216	109	self.pep8_bar = gtk.Statusbar()
217		#self.pep8.connect("show-bar", (lambda w, bar: bar.show_all()), self.pep8_bar)
218		#self.pep8.connect("hide-bar", (lambda w, bar: bar.hide()), self.pep8_bar)
	110	self.pep8.connect("show-bar", (lambda w, bar: bar.show_all()), self.pep8_bar)
	111	self.pep8.connect("hide-bar", (lambda w, bar: bar.hide()), self.pep8_bar)
219	112	self.pep8_bar.label = gtk.Label()
220		#self.pep8.connect("bar-text", (lambda w, t, l: l.set_text(t)), self.pep8_bar.label)
	113	self.pep8.connect("bar-text", (lambda w, t, l: l.set_text(t)), self.pep8_bar.label)
221	114	self.pep8_bar.add(self.pep8_bar.label)
222	115	vbox.pack_end(self.pep8_bar, False, True, 0)
223
224		# Preferencias / preferences
225
226		preferences_toolbar = gtk.Toolbar()
227
228		show_line_numbers = ToggleToolButton('show-numbers')
229		show_line_numbers.set_tooltip(_("Show line numbers"))
230
231		show_line_numbers.set_active(True)
232		show_line_numbers.connect("clicked", \
233		self.editor._set_show_line_numbers)
234		show_line_numbers.show()
235		preferences_toolbar.insert(show_line_numbers, -1)
236
237		self.editor._make_languages_combo(preferences_toolbar)
238		self.editor.make_style_combo(preferences_toolbar)
239	116
240		separator = gtk.SeparatorToolItem()
241		separator.set_draw(False)
242		separator.set_expand(True)
243		preferences_toolbar.insert(separator, -1)
244		separator.show_all()
245
246	117	self.python_console = PythonConsole()
247		self.python_console.showed = False
248		vbox.pack_end(self.python_console, False, True, 0)
249
250		self.python_console.hide()
251
252		python_console_btn = ToolButton("python-console")
253		python_console_btn.set_tooltip(_("Show or hide the python console"))
254		python_console_btn.connect("clicked", self.show_python_console)
255		preferences_toolbar.insert(python_console_btn, -1)
256		python_console_btn.show_all()
	118	self.python_console.show()
	119	vpaned.pack2(self.python_console)
	120	vpaned.show_all()
	121	vbox.show_all()
257	122
258		preferences = ToolbarButton()
259		preferences.props.page = preferences_toolbar
260		preferences.props.icon_name = 'preferences-system'
261		preferences.show_all()
	123	def change_style(self, widget, style):
	124	self.editor.set_style(style)
	125
	126	def language_changed(self, widget, new_lang):
	127	self.toolbar_box.set_active_lang(int(new_lang))
	128
	129	def change_language(self, widget, id, language):
	130	if id == "python":
	131	self.enable_pep8(None, True)
	132	else:
	133	self.enable_pep8(None, False)
	134	self.editor.set_language(language)
262	135
263		self.toolbar_box.toolbar.insert(preferences, -1)
264
265		font_options = FontToolbarButton()
266		font_options.connect("load-pango-context",
267		self.load_pango_context)
268		font_options.load_toolbar()
269		font_options.connect("font-changed", self.change_font)
270		self.toolbar_box.toolbar.insert(font_options, -1)
271		font_options.show()
272
273		# Separador / Separator
274
275		separator = gtk.SeparatorToolItem()
276		separator.set_draw(False)
277		separator.set_expand(True)
278		self.toolbar_box.toolbar.insert(separator, -1)
279
280		# Boton salir / Stop Button
281
282		exit = StopButton(self)
283		self.toolbar_box.toolbar.insert(exit, -1)
284
285		self.toolbar_box.show_all()
286
287		self.set_toolbar_box(self.toolbar_box)
288
289	136	def show_python_console(self, widget):
290	137	if not self.python_console.showed:
291	138	self.python_console.show()
…	…
142	142	self.python_console.hide()
143	143	self.python_console.showed = False
144	144
145		def _search_entry_activate_cb(self, entry):
146		self.editor.set_search_text(entry.props.text)
	145	def _search_text(self, widget, text):
	146	self.editor.set_search_text(text)
147	147	self.update_search_buttons()
148
149		def _search_entry_changed_cb(self, entry):
150		self.editor.set_search_text(entry.props.text)
151		self.update_search_buttons()
152	148
153	149	def update_search_buttons(self):
154	150	if len(self.editor.search_text) == 0:
…	…
159	159	self._search_next.props.sensitive = next_result != _1
160	160
161	161	def enable_pep8(self, widget, active):
162		self.edit_toolbar.pep8_btn.set_visible(active)
163		self.edit_toolbar.pep8_datetime_separator.set_draw(active)
	162	self.toolbar_box.set_pep8_sensitive(active)
164	163
165	164	def change_font(self, widget, family, face, size):
166		self.editor.modify_font(
167		pango.FontDescription("%s %s %d" % (family, face, size)))
	165	self.editor.modify_font(pango.FontDescription("%s %s %d" %
	166	(family,
	167	face,
	168	size)))
168	169
169		def load_pango_context(self, widget):
170		return self.editor.get_pango_context()
171
172	170	def pep8_check(self, widget):
173	171	self.pep8.check_file(self.editor)
174	172
…	…
207	207	file.close()
208	208
209	209	def new(self, widget):
210		self.editor.pep8.check_exit()
	210	self.pep8.check_exit(self.editor.get_buffer(), self.editor._get_all_text())
211	211	_continue = self.save_file(None, type="exit")
212	212	if _continue:
213	213	self.metadata["mime_type"] = mime.GENERIC_TYPE_TEXT
214	214	self.editor.lang = None
215	215	self.editor.file = None
216		self.editor.lang_combo.set_active(0)
	216	self.toolbar_box.set_active_lang(0)
217	217	self.editor.buffer.set_highlight_syntax(False)
218		self.edit_toolbar.pep8_btn.hide()
219		self.edit_toolbar.pep8_datetime_separator.set_draw(
220		False)
	218	self.toolbar_box.set_pep8_sensitive(False)
221	219	self.editor.buffer.set_text("")
222	220	self.set_title(_("New"))
223	221


34	34	from sugar.graphics.combobox import ComboBox
35	35	from sugar.graphics.toolcombobox import ToolComboBox
36	36
37		STYLE_MANAGER = gtksourceview2.style_scheme_manager_get_default()
38		# Style Files extracted from / Archivos Style extraidos de :
39		# http://live.gnome.org/GtkSourceView/StyleSchemes
40		STYLE_MANAGER.append_search_path(os.path.join(os.environ["SUGAR_BUNDLE_PATH"],
41		"styles"))
42		STYLES = STYLE_MANAGER.get_scheme_ids()
43	37	LANGUAGE_MANAGER = gtksourceview2.language_manager_get_default()
44		LANGUAGES = LANGUAGE_MANAGER.get_language_ids()
45	38
46
47	39	class Editor(gtksourceview2.View):
48	40	__gsignals__ = {"pep8-aviable": (gobject.SIGNAL_RUN_LAST,
49	41	gobject.TYPE_NONE,
50		(gobject.TYPE_BOOLEAN,)),}
	42	(gobject.TYPE_BOOLEAN,)),
	43	"language-changed": (gobject.SIGNAL_RUN_LAST,
	44	gobject.TYPE_NONE,
	45	(gobject.TYPE_STRING,)),}
51	46	def __init__(self):
52	47	gtksourceview2.View.__init__(self)
53	48
…	…
69	69	self._tagtable.add(self.error_tag)
70	70
71	71	self.buffer = gtksourceview2.Buffer(tag_table=self._tagtable)
	72	self.buffer.set_highlight_syntax(True)
72	73	self.set_buffer(self.buffer)
73	74
74	75	self.show_all()
75	76
76		def _set_style(self, widget):
77		name = self.style_combo.get_active()
78		id = STYLES[name]
79		self.buffer.set_style_scheme(STYLE_MANAGER.get_scheme(id))
	77	def set_style(self, style):
	78	self.buffer.set_style_scheme(style)
80	79
81		def make_style_combo(self, toolbar):
82		self.style_combo = ComboBox()
83		count = 0
84		classic = 0
85		for style in STYLES:
86		self.style_combo.append_item(None, style.capitalize())
87		if style == "classic":
88		classic = count
89		count += 1
90		self.style_combo.set_active(classic)
91		self.style_combo.connect("changed", self._set_style)
92		tool_item = ToolComboBox(self.style_combo)
93		toolbar.insert(tool_item, -1)
94		tool_item.show_all()
	80	def _set_show_line_numbers(self, widget, active):
	81	self.set_show_line_numbers(active)
95	82
96		def _set_show_line_numbers(self, button):
97		if button.get_active():
98		self.set_show_line_numbers(True)
99		else:
100		self.set_show_line_numbers(False)
101
102	83	def _copy_cb(self, widget):
103	84	clipboard = gtk.Clipboard()
104	85
…	…
103	103	def _redo_cb(self, widget):
104	104	self.buffer.redo()
105	105
106		def _make_languages_combo(self, toolbar):
107		self.lang_combo = ComboBox()
108		self.lang_combo.append_item(None, _("Plain text"))
109		self.lang_combo.set_active(0)
	106	def set_language(self, lang):
	107	self.lang = lang
	108	self.buffer.set_language(lang)
110	109
111		for lang in LANGUAGES:
112		self.lang_combo.append_item(None, lang.capitalize())
113
114		self.lang_combo.connect("changed", self._set_language)
115
116		tool_item = ToolComboBox(self.lang_combo)
117		toolbar.insert(tool_item, -1)
118
119		tool_item.show()
120
121		def _set_language(self, combo):
122		name = self.lang_combo.get_active()
123		if name != 0:
124		id = LANGUAGES[name - 1]
125		self.lang = LANGUAGE_MANAGER.get_language(id)
126		self.buffer.set_highlight_syntax(True)
127		self.buffer.set_language(self.lang)
128		if id == "python":
129		self.emit("pep8-aviable", True)
130		else:
131		self.emit("pep8-aviable", False)
132
133		elif name == 0:
134		self.buffer.set_highlight_syntax(False)
135		self.lang = None
136		self.emit("pep8-aviable", False)
137
138	110	def _search_and_active_language(self, mimetype):
139	111	encontrado = False
140	112	for id in LANGUAGES:
…	…
114	114	if len(lang.get_mime_types()):
115	115	mime = lang.get_mime_types()[0]
116	116	if mimetype == mime:
117		self.buffer.set_highlight_syntax(True)
118	117	self.buffer.set_language(lang)
119	118	list_num = LANGUAGES.index(id)
120		self.lang_combo.set_active(
121		list_num + 1)
	119	self.emit("language-changed", list_num + 1)
122	120	encontrado = True
123	121
124	122	if id == "python":
…	…
124	124	else:
125	125	self.emit("pep8-aviable", False)
126	126	if not encontrado:
127		self.buffer.set_highlight_syntax(False)
128		self.lang_combo.set_active(0)
	127	self.buffer.set_language(None)
	128	self.emit("language-changed", 0)
129	129	self.lang = None
130	130	self.emit("pep8-aviable", False)
131	131
…	…
220	220	_buffer.place_cursor(start)
221	221
222	222	self.scroll_to_iter(start, 0.1)
	223
223	224	self.scroll_to_iter(end, 0.1)


	1		#!/usr/bin/env python
	2		# -- coding: UTF-8 --
	3
	4		# font_options.py by/por:
	5		# Daniel Francis <santiago.danielfrancis@gmail.com>
	6		# Agustin Zubiaga <aguzubiaga97@gmail.com>
	7		# Sugarlabs - CeibalJAM! - Uruguay
	8
	9		# This program is free software; you can redistribute it and/or modify
	10		# it under the terms of the GNU General Public License as published by
	11		# the Free Software Foundation; either version 3 of the License, or
	12		# (at your option) any later version.
	13		#
	14		# This program is distributed in the hope that it will be useful,
	15		# but WITHOUT ANY WARRANTY; without even the implied warranty of
	16		# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17		# GNU General Public License for more details.
	18		#
	19		# You should have received a copy of the GNU General Public License
	20		# along with this program; if not, write to the Free Software
	21		# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	22
	23		import gobject
	24		import gtk
	25
	26		from sugar.graphics.combobox import ComboBox
	27		from sugar.graphics.toolcombobox import ToolComboBox
	28		from sugar.activity.widgets import ToolbarButton
	29
	30
	31		class FontToolbarButton(ToolbarButton):
	32		__gsignals__ = {'load-pango-context': (gobject.SIGNAL_RUN_LAST,
	33		gobject.TYPE_PYOBJECT,
	34		tuple()),
	35		'font-changed': (gobject.SIGNAL_RUN_LAST,
	36		gobject.TYPE_NONE,
	37		(gobject.TYPE_STRING,
	38		gobject.TYPE_STRING,
	39		gobject.TYPE_INT))}
	40
	41		def __init__(self):
	42		ToolbarButton.__init__(self)
	43		self.toolbar = gtk.Toolbar()
	44		self.props.page = self.toolbar
	45		self.props.icon_name = 'format-text'
	46		self.family = "Monospace"
	47		self.current_face = "Regular"
	48
	49		def size_changed(self, adjustment):
	50		self.emit("font-changed", self.family,
	51		self.current_face, adjustment.get_value())
	52
	53		def face_changed(self, widget):
	54		iter = widget.get_active_iter()
	55		self.current_face = self.faces[self.family].get_value(iter, 0)
	56		self.emit('font-changed', self.family,
	57		self.current_face, self.size_adj.get_value())
	58
	59		def family_changed(self, widget):
	60		iter = widget.get_active_iter()
	61		self.family = self.family_model.get_value(iter, 0)
	62		self.face_combo.set_model(self.faces[self.family])
	63		self.face_combo.set_active(0)
	64
	65		def load_toolbar(self):
	66		self.context = self.emit("load-pango-context")
	67		self.family_combo = ComboBox()
	68		family_renderer = gtk.CellRendererText()
	69		family_renderer.set_property("family-set", True)
	70		self.family_combo.pack_start(family_renderer)
	71		self.family_combo.add_attribute(family_renderer, 'text', 0)
	72		self.family_combo.add_attribute(family_renderer, 'family', 0)
	73		self.family_model = gtk.ListStore(str)
	74		monospace_index = 0
	75		count = 0
	76		self.faces = {}
	77		for i in self.context.list_families():
	78		name = i.get_name()
	79		monospace_index = count if name == "Monospace" else 0
	80		count += 1
	81		self.family_model.append([name])
	82		family_faces = gtk.ListStore(str, str)
	83		for face in i.list_faces():
	84		face_name = face.get_face_name()
	85		family_faces.append([face_name,
	86		"%s %s" %
	87		(name, face_name)])
	88		self.faces[name] = family_faces
	89		self.family_combo.set_model(self.family_model)
	90		self.family_combo.set_active(monospace_index)
	91		self.family_combo.connect("changed", self.family_changed)
	92		self.family_combo.show()
	93		self.family_tool_item = ToolComboBox(self.family_combo)
	94		self.family_tool_item.show()
	95		self.toolbar.insert(self.family_tool_item, -1)
	96
	97		self.face_combo = ComboBox()
	98		face_renderer = gtk.CellRendererText()
	99		face_renderer.set_property("family-set", True)
	100		self.face_combo.pack_start(face_renderer)
	101		self.face_combo.add_attribute(face_renderer, 'text', 0)
	102		self.face_combo.add_attribute(face_renderer, 'font', 1)
	103		current_model = self.faces["Monospace"]
	104		self.face_combo.set_model(current_model)
	105		self.face_combo.set_active(0)
	106		self.face_combo.connect("changed", self.face_changed)
	107		self.face_combo.show()
	108		self.face_tool_item = ToolComboBox(self.face_combo)
	109		self.face_tool_item.show()
	110		self.toolbar.insert(self.face_tool_item, -1)
	111
	112		self.size_adj = gtk.Adjustment(value=10, lower=5,
	113		upper=100, step_incr=1)
	114		self.size_adj.connect("value-changed", self.size_changed)
	115		self.size_spin = gtk.SpinButton(self.size_adj)
	116		self.size_spin.show()
	117		self.size_spin_item = gtk.ToolItem()
	118		self.size_spin_item.add(self.size_spin)
	119		self.size_spin_item.show()
	120		self.toolbar.insert(self.size_spin_item, -1)
	121
	122		self.toolbar.show()


		1	#!/usr/bin/env python
		2	# -- coding: utf-8 --
		3
		4	# activity.py by/por:
		5	# Agustin Zubiaga <aguzubiaga97@gmail.com>
		6	# Daniel Francis <santiago.danielfrancis@gmail.com>
		7	# Sugarlabs - CeibalJAM! - Uruguay
		8
		9	# This program is free software; you can redistribute it and/or modify
		10	# it under the terms of the GNU General Public License as published by
		11	# the Free Software Foundation; either version 2 of the License, or
		12	# (at your option) any later version.
		13	#
		14	# This program is distributed in the hope that it will be useful,
		15	# but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		17	# GNU General Public License for more details.
		18	#
		19	# You should have received a copy of the GNU General Public License
		20	# along with this program; if not, write to the Free Software
		21	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
		22	# MA 02110-1301, USA.
		23	#
		24
		25	import os
		26
		27	import gobject
		28	import gtk
		29
		30	import gtksourceview2
		31	STYLE_MANAGER = gtksourceview2.style_scheme_manager_get_default()
		32	# Style Files extracted from / Archivos Style extraidos de :
		33	# http://live.gnome.org/GtkSourceView/StyleSchemes
		34	STYLE_MANAGER.append_search_path(os.path.join(os.environ["SUGAR_BUNDLE_PATH"],
		35	"styles"))
		36	STYLES = STYLE_MANAGER.get_scheme_ids()
		37	LANGUAGE_MANAGER = gtksourceview2.language_manager_get_default()
		38	LANGUAGES = LANGUAGE_MANAGER.get_language_ids()
		39
		40	from sugar.activity.widgets import EditToolbar, StopButton, \
		41	ActivityToolbarButton, ToolbarButton
		42	from sugar.graphics import iconentry
		43	from sugar.graphics.combobox import ComboBox
		44	from sugar.graphics.toolbutton import ToolButton
		45	from sugar.graphics.toggletoolbutton import ToggleToolButton
		46	from sugar.graphics.toolcombobox import ToolComboBox
		47	from sugar.graphics.toolbarbox import ToolbarBox
		48
		49	class MainOptions(ActivityToolbarButton):
		50	__gsignals__ = {'open-from-journal': (gobject.SIGNAL_RUN_LAST,
		51	gobject.TYPE_NONE,
		52	tuple()),
		53	'open-file': (gobject.SIGNAL_RUN_LAST,
		54	gobject.TYPE_NONE,
		55	tuple()),
		56	'save-file': (gobject.SIGNAL_RUN_LAST,
		57	gobject.TYPE_NONE,
		58	tuple()),
		59	'save-as': (gobject.SIGNAL_RUN_LAST,
		60	gobject.TYPE_NONE,
		61	tuple()),
		62	'new-file': (gobject.SIGNAL_RUN_LAST,
		63	gobject.TYPE_NONE,
		64	tuple())}
		65	def __init__(self, activity):
		66	ActivityToolbarButton.__init__(self, activity)
		67
		68	# Abrir objeto / Open object
		69	self.open_obj_btn = ToolButton("open-from-journal")
		70	self.open_obj_btn.set_tooltip(_("Open object from journal"))
		71	self.open_obj_btn.connect_object("clicked", self.emit, 'open-from-journal')
		72	self.page.insert(self.open_obj_btn, -1)
		73
		74	# Separador / Separator
		75	separator = gtk.SeparatorToolItem()
		76	separator.set_draw(True)
		77	separator.set_expand(False)
		78	self.page.insert(separator, -1)
		79
		80	# Boton de Abrir Archivo / Open File button
		81	self.open_btn = ToolButton("fileopen")
		82	self.open_btn.set_tooltip(_("Open File"))
		83	self.open_btn.set_accelerator('<ctrl>o')
		84	self.open_btn.connect_object("clicked", self.emit, 'open-file')
		85	self.page.insert(self.open_btn, -1)
		86
		87	# **** Save File button ****
		88	self.save_btn = ToolButton("stock_save")
		89	self.save_btn.set_tooltip(_("Save this file"))
		90	self.save_btn.set_accelerator('<ctrl>s')
		91	self.save_btn.connect_object("clicked", self.emit, 'save-file')
		92	self.page.insert(self.save_btn, -1)
		93
		94	self.page.show_all()
		95	self.page.stop.hide()
		96
		97	# Guardar como / Save As
		98	self.save_as = gtk.MenuItem(_("Save on the file system."))
		99	self.page.keep.props.palette.menu.append(self.save_as)
		100	self.save_as.connect_object("activate", self.emit, "save-as")
		101	self.save_as.show()
		102
		103	# Nuevo / New
		104	self.new = ToolButton("new")
		105	self.new.set_tooltip(_("New file"))
		106	self.new.set_accelerator('<ctrl>n')
		107	self.new.connect_object("clicked", self.emit, 'new-file')
		108	self.page.insert(self.new, 6)
		109	self.new.show()
		110
		111	self.page.keep.show()
		112
		113	class EditOptions(ToolbarButton):
		114	__gsignals__ = {'pep8-check': (gobject.SIGNAL_RUN_LAST,
		115	gobject.TYPE_NONE,
		116	tuple()),
		117	'insert-datetime': (gobject.SIGNAL_RUN_LAST,
		118	gobject.TYPE_NONE,
		119	tuple()),
		120	'copy': (gobject.SIGNAL_RUN_LAST,
		121	gobject.TYPE_NONE,
		122	tuple()),
		123	'paste': (gobject.SIGNAL_RUN_LAST,
		124	gobject.TYPE_NONE,
		125	tuple()),
		126	'undo': (gobject.SIGNAL_RUN_LAST,
		127	gobject.TYPE_NONE,
		128	tuple()),
		129	'redo': (gobject.SIGNAL_RUN_LAST,
		130	gobject.TYPE_NONE,
		131	tuple()),
		132	'cut': (gobject.SIGNAL_RUN_LAST,
		133	gobject.TYPE_NONE,
		134	tuple())}
		135
		136	def __init__(self):
		137	self._toolbar = EditToolbar()
		138	ToolbarButton.__init__(self, label=_("Edit"), page=self._toolbar, icon_name='toolbar-edit')
		139
		140	self.cut = ToolButton("cut")
		141	self.cut.set_tooltip(_("Cut"))
		142	self.cut.set_accelerator('<ctrl>x')
		143	self._toolbar.insert(self.cut, 4)
		144
		145	separator = gtk.SeparatorToolItem()
		146	separator.set_draw(False)
		147	separator.set_expand(True)
		148	self._toolbar.insert(separator, -1)
		149
		150	self.pep8_btn = ToolButton('pep8')
		151	self.pep8_btn.set_tooltip(_("PEP 8 Check"))
		152	self.pep8_btn.connect_object("clicked", self.emit, 'pep8-check')
		153	self._toolbar.insert(self.pep8_btn, -1)
		154
		155	self.pep8_datetime_separator = gtk.SeparatorToolItem()
		156	self.pep8_datetime_separator.set_draw(True)
		157	self._toolbar.insert(self.pep8_datetime_separator, -1)
		158
		159	self.insert_datetime = ToolButton("insert-datetime")
		160	self.insert_datetime.connect_object("clicked", self.emit, 'insert-datetime')
		161	# self.editor._insert_date_time)
		162	self.insert_datetime.set_tooltip(_("Insert date and time"))
		163	self._toolbar.insert(self.insert_datetime, -1)
		164	self.insert_datetime.show_all()
		165
		166	self._toolbar.copy.connect_object("clicked", self.emit, 'copy')
		167	self._toolbar.paste.connect_object("clicked", self.emit, 'paste')
		168	self._toolbar.undo.connect_object("clicked", self.emit, 'undo')
		169	self._toolbar.redo.connect_object("clicked", self.emit, 'redo')
		170	self.cut.connect_object("clicked", self.emit, 'cut')
		171
		172	self._toolbar.show_all()
		173	self.pep8_btn.set_sensitive(False)
		174	self.pep8_datetime_separator.set_draw(False)
		175
		176	def set_pep8_sensitive(self, sensitive):
		177	self.pep8_btn.set_sensitive(sensitive)
		178
		179	class PreferencesOptions(ToolbarButton):
		180	__gsignals__ = {'show-line-numbers': (gobject.SIGNAL_RUN_LAST,
		181	gobject.TYPE_NONE,
		182	(gobject.TYPE_BOOLEAN,)),
		183	'language-changed': (gobject.SIGNAL_RUN_LAST,
		184	gobject.TYPE_NONE,
		185	(gobject.TYPE_STRING,
		186	gobject.TYPE_PYOBJECT)),
		187	'style-changed': (gobject.SIGNAL_RUN_LAST,
		188	gobject.TYPE_NONE,
		189	(gobject.TYPE_PYOBJECT,))}
		190	def __init__(self):
		191	ToolbarButton.__init__(self)
		192	self._toolbar = gtk.Toolbar()
		193
		194	self.show_line_numbers = ToggleToolButton('show-numbers')
		195	self.show_line_numbers.set_tooltip(_("Show line numbers"))
		196	self.show_line_numbers.set_active(True)
		197	self.show_line_numbers.connect("clicked", (lambda w,s: s.emit('show-line-numbers', w.get_active())), self)
		198	# self.editor._set_show_line_numbers)
		199	self.show_line_numbers.show()
		200	self._toolbar.insert(self.show_line_numbers, -1)
		201
		202	#Languages Combo Box
		203	self.lang_combo = ComboBox()
		204	self.lang_combo.append_item(None, _("Plain text"))
		205	self.lang_combo.set_active(0)
		206	for lang in LANGUAGES:
		207	self.lang_combo.append_item(None, lang.capitalize())
		208	self.lang_combo.connect("changed", self._lang_changed)
		209	self.lang_item = ToolComboBox(self.lang_combo)
		210	self._toolbar.insert(self.lang_item, -1)
		211	self.lang_item.show()
		212
		213	self.style_combo = ComboBox()
		214	count = 0
		215	classic = 0
		216	for style in STYLES:
		217	self.style_combo.append_item(None, style.capitalize())
		218	if style == "classic":
		219	classic = count
		220	count += 1
		221	self.style_combo.set_active(classic)
		222	self.style_combo.connect("changed", (lambda w,s: self.emit('style-changed', STYLE_MANAGER.get_scheme(STYLES[w.get_active()]))), self)
		223	self.style_item = ToolComboBox(self.style_combo)
		224	self._toolbar.insert(self.style_item, -1)
		225	self.style_item.show_all()
		226
		227	self.props.page = self._toolbar
		228	self.props.icon_name = 'preferences-system'
		229
		230	def _lang_changed(self, widget):
		231	name = widget.get_active()
		232	if name != 0:
		233	id = LANGUAGES[name - 1]
		234	lang = LANGUAGE_MANAGER.get_language(id)
		235	else:
		236	id = None
		237	lang = None
		238	self.emit('language-changed', id, lang)
		239
		240	def set_active_lang(self, index):
		241	self.lang_combo.set_active(index)
		242
		243	class FontOptions(ToolbarButton):
		244	__gsignals__ = {'font-changed': (gobject.SIGNAL_RUN_LAST,
		245	gobject.TYPE_NONE,
		246	(gobject.TYPE_STRING,
		247	gobject.TYPE_STRING,
		248	gobject.TYPE_INT))}
		249
		250	def __init__(self, context):
		251	ToolbarButton.__init__(self)
		252	self.context = context
		253	self.toolbar = gtk.Toolbar()
		254	self.props.page = self.toolbar
		255	self.props.icon_name = 'format-text'
		256	self.family = "Monospace"
		257	self.current_face = "Regular"
		258	self.family_combo = ComboBox()
		259	family_renderer = gtk.CellRendererText()
		260	family_renderer.set_property("family-set", True)
		261	self.family_combo.pack_start(family_renderer)
		262	self.family_combo.add_attribute(family_renderer, 'text', 0)
		263	self.family_combo.add_attribute(family_renderer, 'family', 0)
		264	self.family_model = gtk.ListStore(str)
		265	monospace_index = 0
		266	count = 0
		267	self.faces = {}
		268
		269	for i in self.context.list_families():
		270	name = i.get_name()
		271	monospace_index = count if name == "Monospace" else 0
		272	count += 1
		273	self.family_model.append([name])
		274	family_faces = gtk.ListStore(str, str)
		275	for face in i.list_faces():
		276	face_name = face.get_face_name()
		277	family_faces.append([face_name,
		278	"%s %s" %
		279	(name, face_name)])
		280	self.faces[name] = family_faces
		281	self.family_combo.set_model(self.family_model)
		282	self.family_combo.set_active(monospace_index)
		283	self.family_combo.connect("changed", self.family_changed)
		284	self.family_combo.show()
		285	self.family_tool_item = ToolComboBox(self.family_combo)
		286	self.family_tool_item.show()
		287	self.toolbar.insert(self.family_tool_item, -1)
		288
		289	self.face_combo = ComboBox()
		290	face_renderer = gtk.CellRendererText()
		291	face_renderer.set_property("family-set", True)
		292	self.face_combo.pack_start(face_renderer)
		293	self.face_combo.add_attribute(face_renderer, 'text', 0)
		294	self.face_combo.add_attribute(face_renderer, 'font', 1)
		295	current_model = self.faces["Monospace"]
		296	self.face_combo.set_model(current_model)
		297	self.face_combo.set_active(0)
		298	self.face_combo.connect("changed", self.face_changed)
		299	self.face_combo.show()
		300	self.face_tool_item = ToolComboBox(self.face_combo)
		301	self.face_tool_item.show()
		302	self.toolbar.insert(self.face_tool_item, -1)
		303
		304	self.size_adj = gtk.Adjustment(value=10, lower=5,
		305	upper=100, step_incr=1)
		306	self.size_adj.connect("value-changed", self.size_changed)
		307	self.size_spin = gtk.SpinButton(self.size_adj)
		308	self.size_spin.show()
		309	self.size_spin_item = gtk.ToolItem()
		310	self.size_spin_item.add(self.size_spin)
		311	self.size_spin_item.show()
		312	self.toolbar.insert(self.size_spin_item, -1)
		313
		314	self.toolbar.show()
		315
		316	def size_changed(self, adjustment):
		317	self.emit("font-changed", self.family,
		318	self.current_face, adjustment.get_value())
		319
		320	def face_changed(self, widget):
		321	iter = widget.get_active_iter()
		322	self.current_face = self.faces[self.family].get_value(iter, 0)
		323	self.emit('font-changed', self.family,
		324	self.current_face, self.size_adj.get_value())
		325
		326	def family_changed(self, widget):
		327	iter = widget.get_active_iter()
		328	self.family = self.family_model.get_value(iter, 0)
		329	self.face_combo.set_model(self.faces[self.family])
		330	self.face_combo.set_active(0)
		331
		332
		333	class OptionWidget(ToolbarBox):
		334	__gsignals__ = {'open-from-journal': (gobject.SIGNAL_RUN_LAST,
		335	gobject.TYPE_NONE,
		336	tuple()),
		337	'open-file': (gobject.SIGNAL_RUN_LAST,
		338	gobject.TYPE_NONE,
		339	tuple()),
		340	'save-file': (gobject.SIGNAL_RUN_LAST,
		341	gobject.TYPE_NONE,
		342	tuple()),
		343	'save-as': (gobject.SIGNAL_RUN_LAST,
		344	gobject.TYPE_NONE,
		345	tuple()),
		346	'new-file': (gobject.SIGNAL_RUN_LAST,
		347	gobject.TYPE_NONE,
		348	tuple()),
		349	'pep8-check': (gobject.SIGNAL_RUN_LAST,
		350	gobject.TYPE_NONE,
		351	tuple()),
		352	'insert-datetime': (gobject.SIGNAL_RUN_LAST,
		353	gobject.TYPE_NONE,
		354	tuple()),
		355	'copy': (gobject.SIGNAL_RUN_LAST,
		356	gobject.TYPE_NONE,
		357	tuple()),
		358	'paste': (gobject.SIGNAL_RUN_LAST,
		359	gobject.TYPE_NONE,
		360	tuple()),
		361	'undo': (gobject.SIGNAL_RUN_LAST,
		362	gobject.TYPE_NONE,
		363	tuple()),
		364	'redo': (gobject.SIGNAL_RUN_LAST,
		365	gobject.TYPE_NONE,
		366	tuple()),
		367	'cut': (gobject.SIGNAL_RUN_LAST,
		368	gobject.TYPE_NONE,
		369	tuple()),
		370	'search-text': (gobject.SIGNAL_RUN_LAST,
		371	gobject.TYPE_NONE,
		372	(gobject.TYPE_STRING,)),
		373	'search-prev': (gobject.SIGNAL_RUN_LAST,
		374	gobject.TYPE_NONE,
		375	tuple()),
		376	'search-next': (gobject.SIGNAL_RUN_LAST,
		377	gobject.TYPE_NONE,
		378	tuple()),
		379	'show-line-numbers': (gobject.SIGNAL_RUN_LAST,
		380	gobject.TYPE_NONE,
		381	(gobject.TYPE_BOOLEAN,)),
		382	'language-changed': (gobject.SIGNAL_RUN_LAST,
		383	gobject.TYPE_NONE,
		384	(gobject.TYPE_STRING,
		385	gobject.TYPE_PYOBJECT)),
		386	'style-changed': (gobject.SIGNAL_RUN_LAST,
		387	gobject.TYPE_NONE,
		388	(gobject.TYPE_PYOBJECT,)),
		389	'font-changed': (gobject.SIGNAL_RUN_LAST,
		390	gobject.TYPE_NONE,
		391	(gobject.TYPE_STRING,
		392	gobject.TYPE_STRING,
		393	gobject.TYPE_INT))}
		394	def __init__(self, activity, context):
		395	ToolbarBox.__init__(self)
		396
		397	self.main_options = MainOptions(activity)
		398	self.main_options.connect_object('open-from-journal', self.emit, 'open-from-journal')
		399	self.main_options.connect_object('open-file', self.emit, 'open-file')
		400	self.main_options.connect_object('save-file', self.emit, 'save-file')
		401	self.main_options.connect_object('save-as', self.emit, 'save-as')
		402	self.main_options.connect_object('new-file', self.emit, 'new-file')
		403	self.toolbar.insert(self.main_options, 0)
		404
		405	self.edit_options = EditOptions()
		406	self.edit_options.connect_object('pep8-check', self.emit, 'pep8-check')
		407	self.edit_options.connect_object('insert-datetime', self.emit,'insert-datetime')
		408	self.edit_options.connect_object('copy', self.emit, 'copy')
		409	self.edit_options.connect_object('paste', self.emit, 'paste')
		410	self.edit_options.connect_object('undo', self.emit, 'undo')
		411	self.edit_options.connect_object('redo', self.emit, 'redo')
		412	self.edit_options.connect_object('cut', self.emit, 'cut')
		413	self.toolbar.insert(self.edit_options, -1)
		414
		415	# Separador / Separator
		416	separator = gtk.SeparatorToolItem()
		417	separator.set_draw(False)
		418	self.toolbar.insert(separator, -1)
		419
		420	# Buscar / Search
		421	self.search_entry = iconentry.IconEntry()
		422	self.search_entry.set_size_request(gtk.gdk.screen_width() / 3, -1)
		423	self.search_entry.set_icon_from_name(
		424	iconentry.ICON_ENTRY_PRIMARY, 'system-search')
		425	self.search_entry.add_clear_button()
		426	self.search_entry.connect('activate', (lambda w,s: self.emit('search-text', w.props.text)), self)
		427	# self._search_entry_activate_cb)
		428	self.search_entry.connect('changed', (lambda w,s: self.emit('search-text', w.props.text)), self)
		429	# self._search_entry_changed_cb)
		430	self.search_item = gtk.ToolItem()
		431	self.search_item.add(self.search_entry)
		432	self.toolbar.insert(self.search_item, -1)
		433
		434	self._search_prev = ToolButton('go-previous-paired')
		435	self._search_prev.set_tooltip(_('Previous'))
		436	self._search_prev.connect_object('clicked', self.emit, 'search-prev')
		437	# self.editor._search_prev_cb)
		438	self.toolbar.insert(self._search_prev, -1)
		439
		440	self._search_next = ToolButton('go-next-paired')
		441	self._search_next.set_tooltip(_('Next'))
		442	self._search_next.connect_object('clicked', self.emit, 'search-next')
		443	# self.editor._search_next_cb)
		444	self.toolbar.insert(self._search_next, -1)
		445
		446	self.preferences_options = PreferencesOptions()
		447	self.preferences_options.connect('show-line-numbers', (lambda w,a,s: s.emit('show-line-numbers', a)), self)
		448	self.preferences_options.connect('language-changed', (lambda w,i,l,s: s.emit('language-changed', i, l)), self)
		449	self.preferences_options.connect('style-changed', (lambda w,st,s: s.emit('style-changed', st)), self)
		450	self.preferences_options.show_all()
		451	self.toolbar.insert(self.preferences_options, -1)
		452
		453	self.font_options = FontOptions(context)
		454	self.font_options.connect("font-changed", (lambda w,fav,fac,siz,s: s.emit('font-changed', fav, fac, siz)), self)
		455	self.toolbar.insert(self.font_options, -1)
		456	self.font_options.show()
		457
		458	# Separador / Separator
		459
		460	separator = gtk.SeparatorToolItem()
		461	separator.set_draw(False)
		462	separator.set_expand(True)
		463	self.toolbar.insert(separator, -1)
		464
		465	# Boton salir / Stop Button
		466
		467	exit = StopButton(activity)
		468	self.toolbar.insert(exit, -1)
		469
		470	self.set_active_lang = self.preferences_options.set_active_lang
		471	self.set_pep8_sensitive = self.edit_options.set_pep8_sensitive
		472
		473	def set_search_prev_sensitive(self, sensitive):
		474	self._search_prev.set_sensitive(sensitive)
		475
		476	def set_search_next_sensitive(self, sensitive):
		477	self._search_next.set_sensitive(sensitive)


19	19	# along with this program; if not, write to the Free Software
20	20	# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21	21
22
23		import logging
	22	import gobject
24	23	import gtk
25	24
26		log = logging.getLogger('EditJam')
27		log.setLevel(logging.DEBUG)
28		logging.basicConfig()
29	25	import commands
30	26
31	27
32		class PEP8_Check():
	28	class PEP8_Check(gobject.GObject):
	29	__gsignals__ = {"hide-bar": (gobject.SIGNAL_RUN_LAST,
	30	gobject.TYPE_NONE,
	31	tuple()),
	32	"show-bar": (gobject.SIGNAL_RUN_LAST,
	33	gobject.TYPE_NONE,
	34	tuple()),
	35	"bar-text": (gobject.SIGNAL_RUN_LAST,
	36	gobject.TYPE_NONE,
	37	(gobject.TYPE_STRING,)),}
	38	def __init__(self):
	39	gobject.GObject.__init__(self)
33	40
34		def __init__(self, activity):
35		self.activity = activity
36
37		def check_file(self, text, editor):
	41	def check_file(self, editor):
	42	text = editor._get_all_text()
38	43	tmp_file = open("/tmp/jamedit-pep8-chk.py", "w")
39	44	tmp_file.write(text)
40	45	tmp_file.close()
41	46
42	47	chk = self.get_check()
43	48
44		self.highlight_errors(editor, chk)
	49	self.highlight_errors(text, chk, editor)
45	50
46		def highlight_errors(self, editor, chk):
47		text = editor._get_all_text()
48		editor.buffer.set_text("")
	51	def highlight_errors(self, text, chk, editor):
	52	buffer = editor.get_buffer()
	53	buffer.set_text("")
49	54	num = 0
50	55	for line in text.split("\n"):
51	56	num += 1
52	57	if str(num) in chk:
53		line_iter = editor.buffer.get_iter_at_line(num + 2)
	58	line_iter = buffer.get_iter_at_line(num + 2)
54	59	if num == len(text.split("\n")) - 1:
55		editor.buffer.insert_with_tags(line_iter, line, \
56		editor.error_tag)
	60	buffer.insert_with_tags(line_iter, line, \
	61	editor.error_tag)
57	62	else:
58		editor.buffer.insert_with_tags(line_iter, line + "\n", \
59		editor.error_tag)
	63	buffer.insert_with_tags(line_iter, line + "\n", \
	64	editor.error_tag)
60	65	else:
61		line_iter = editor.buffer.get_iter_at_line(num)
	66	line_iter = buffer.get_iter_at_line(num)
62	67	if num == len(text.split("\n")) - 1:
63		editor.buffer.insert_with_tags_by_name(line_iter, line)
	68	buffer.insert_with_tags_by_name(line_iter, line)
64	69	else:
65		editor.buffer.insert_with_tags_by_name(line_iter, \
66		line + "\n")
	70	buffer.insert_with_tags_by_name(line_iter, \
	71	line + "\n")
67	72	editor.connect("move-cursor", self.set_bar_text, chk)
68	73
69	74	def get_check(self):
…	…
104	104	this_line_error = check[str(line)]
105	105	char = this_line_error.split(":")[0]
106	106	this_line_error = this_line_error.split(":")[1]
107		self.activity.pep8_bar.label.set_text(
108		str(line) + ":" + char + " " + this_line_error)
	107	self.emit("bar-text",
	108	str(line) + ":" + char + " " + this_line_error)
109	109	print this_line_error
110		self.activity.pep8_bar.show_all()
	110	self.emit("show-bar")
111	111	else:
112	112	pass
113	113
114		def check_exit(self):
115		text = self.activity.editor._get_all_text()
116		self.activity.editor.buffer.set_text("")
117		editor = self.activity.editor
	114	def check_exit(self, buffer, text):
	115	buffer.set_text("")
118	116	num = 0
119	117	for line in text.split("\n"):
120	118	num += 1
121		line_iter = editor.buffer.get_iter_at_line(num)
	119	line_iter = buffer.get_iter_at_line(num)
122	120	if num == len(text.split("\n")) - 1:
123		editor.buffer.insert_with_tags_by_name(line_iter, line)
	121	buffer.insert_with_tags_by_name(line_iter, line)
124	122	else:
125		editor.buffer.insert_with_tags_by_name(line_iter, line + "\n")
	123	buffer.insert_with_tags_by_name(line_iter, line + "\n")
126	124
127		self.activity.pep8_bar.hide()
128		self.activity.pep8_bar.label.set_text("")
	125	self.emit("hide-bar")
	126	self.emit("bar-text", "")

Commit 02154f94bd08ed42442d88e885c910c0cf2a3b9d

Gitorious