GObject signal handling implemented

5 files changed, 594 insertions, 448 deletions

diff --git a/activity.py b/activity.py
index de122d3..ae1488f 100644
--- a/activity.py
+++ b/activity.py
@@ -43,12 +43,12 @@ from sugar.datastore import datastore
 from sugar.activity import activity
 
 from pep8_check import PEP8_Check
-from font_options import FontToolbarButton
-from editor import Editor, LANGUAGE_MANAGER, LANGUAGES
+import options
+from editor import Editor
 from python_console import PythonConsole
 import file_choosers
-file_choosers.langsmanager = LANGUAGE_MANAGER
-file_choosers.langs = LANGUAGES
+file_choosers.langsmanager = options.LANGUAGE_MANAGER
+file_choosers.langs = options.LANGUAGES
 
 
 class JAMEdit(activity.Activity):
@@ -62,6 +62,7 @@ class JAMEdit(activity.Activity):
 
                 self.editor = Editor()
                 self.editor.connect("pep8-aviable", self.enable_pep8)
+                self.editor.connect('language-changed', self.language_changed)
                 
                 self.editor.set_size_request(800, 790)
                 scroll = gtk.ScrolledWindow()
@@ -71,220 +72,67 @@ class JAMEdit(activity.Activity):
                 scroll.show_all()
 
                 vbox = gtk.VBox()
-                vbox.pack_start(scroll, True, True, 0)
-                vbox.show_all()
+                vpaned = gtk.VPaned()
+                vpaned.pack1(scroll)
+                vbox.pack_start(vpaned, True, True, 0)
 
                 self.set_canvas(vbox)
 
                 # ****** Toolbars ******
 
-                self.toolbar_box = ToolbarBox()
-
-                activity_button = ActivityToolbarButton(self)
-                activity_toolbar = activity_button.page
-
-                # Abrir objeto / Open object
-                open_obj_btn = ToolButton("open-from-journal")
-                open_obj_btn.connect("clicked",
-                                   file_choosers.open_from_journal, None, self)
-                open_obj_btn.set_tooltip(_("Open object from journal"))
-                activity_toolbar.insert(open_obj_btn, -1)
-
-                # Separador / Separator
-                separator = gtk.SeparatorToolItem()
-                separator.set_draw(True)
-                separator.set_expand(False)
-                activity_toolbar.insert(separator, -1)
-
-                # ****** Open File button ******
-                open_btn = ToolButton("fileopen")
-                open_btn.set_tooltip(_("Open File"))
-                open_btn.set_accelerator('<ctrl>o')
-                open_btn.connect("clicked", self.open_file)
-                activity_toolbar.insert(open_btn, -1)
-
-                # ****** Save File button ******
-                save_btn = ToolButton("stock_save")
-                save_btn.set_tooltip(_("Save this file"))
-                save_btn.set_accelerator('<ctrl>s')
-                save_btn.connect("clicked", self.save_file)
-                activity_toolbar.insert(save_btn, -1)
-
-                activity_toolbar.show_all()
-                activity_toolbar.stop.hide()
-
-                # Guardar como / Save As
-                save_as = gtk.MenuItem(_("Save on the file system."))
-                activity_toolbar.keep.props.palette.menu.append(save_as)
-                save_as.connect("activate", self.save_file_as)
-                save_as.show()
-
-                # Nuevo / New
-                new = ToolButton("new")
-                new.set_tooltip(_("New file"))
-                new.set_accelerator('<ctrl>n')
-                new.connect("clicked", self.new)
-                activity_toolbar.insert(new, 6)
-                new.show()
-
-                activity_toolbar.keep.show()
-
-                self.toolbar_box.toolbar.insert(activity_button, 0)
-
-                # Edicion / Edit Toolbar
-
-                edit_toolbar = EditToolbar()
-                edit_toolbar_button = ToolbarButton(label=_("Edit"),
-                                                    page=edit_toolbar,
-                                                    icon_name='toolbar-edit')
-
-                edit_toolbar.cut = ToolButton("cut")
-                edit_toolbar.cut.set_tooltip(_("Cut"))
-                edit_toolbar.cut.set_accelerator('<ctrl>x')
-                edit_toolbar.insert(edit_toolbar.cut, 4)
-
-                separator = gtk.SeparatorToolItem()
-                separator.set_draw(False)
-                separator.set_expand(True)
-                edit_toolbar.insert(separator, -1)
-
-                edit_toolbar.pep8_btn = ToolButton('pep8')
-                edit_toolbar.pep8_btn.set_tooltip(_("PEP 8 Check"))
-                edit_toolbar.pep8_btn.connect("clicked", self.pep8_check)
-                edit_toolbar.insert(edit_toolbar.pep8_btn, -1)
-
-                edit_toolbar.pep8_datetime_separator = gtk.SeparatorToolItem()
-                edit_toolbar.pep8_datetime_separator.set_draw(True)
-                edit_toolbar.insert(edit_toolbar.pep8_datetime_separator, -1)
-
-                insert_datetime = ToolButton("insert-datetime")
-                insert_datetime.connect("clicked",
-                                        self.editor._insert_date_time)
-                insert_datetime.set_tooltip(_("Insert date and time"))
-                edit_toolbar.insert(insert_datetime, -1)
-                insert_datetime.show_all()
-
-                edit_toolbar.copy.connect("clicked", self.editor._copy_cb)
-                edit_toolbar.paste.connect("clicked", self.editor._paste_cb)
-                edit_toolbar.undo.connect("clicked", self.editor._undo_cb)
-                edit_toolbar.redo.connect("clicked", self.editor._redo_cb)
-                edit_toolbar.cut.connect("clicked", self.editor._cut_cb)
-
-                edit_toolbar.show_all()
-                edit_toolbar.pep8_btn.hide()
-                edit_toolbar.pep8_datetime_separator.set_draw(False)
-
-                self.toolbar_box.toolbar.insert(edit_toolbar_button, -1)
-
-                self.edit_toolbar = edit_toolbar
-
-                # Separador / Separator
-                separator = gtk.SeparatorToolItem()
-                separator.set_draw(False)
-                self.toolbar_box.toolbar.insert(separator, -1)
-
-                # Buscar / Search
-                search_entry = iconentry.IconEntry()
-                search_entry.set_size_request(gtk.gdk.screen_width() / 3, -1)
-                search_entry.set_icon_from_name(
-                        iconentry.ICON_ENTRY_PRIMARY, 'system-search')
-                search_entry.add_clear_button()
-                search_entry.connect('activate',
-                                     self._search_entry_activate_cb)
-                search_entry.connect('changed',
-                                     self._search_entry_changed_cb)
-                search_item = gtk.ToolItem()
-                search_item.add(search_entry)
-                self.toolbox.toolbar.insert(search_item, -1)
-
-                self._search_prev = ToolButton('go-previous-paired')
-                self._search_prev.set_tooltip(_('Previous'))
-                self._search_prev.connect('clicked',
-                                          self.editor._search_prev_cb)
-                self.toolbox.toolbar.insert(self._search_prev, -1)
-
-                self._search_next = ToolButton('go-next-paired')
-                self._search_next.set_tooltip(_('Next'))
-                self._search_next.connect('clicked',
-                                          self.editor._search_next_cb)
-                self.toolbox.toolbar.insert(self._search_next, -1)
+                self.toolbar_box = options.OptionWidget(self, self.editor.get_pango_context())
+                self.toolbar_box.connect('open-from-journal', file_choosers.open_from_journal, None, self)
+                self.toolbar_box.connect('open-file', self.open_file)
+                self.toolbar_box.connect('save-file', self.save_file)
+                self.toolbar_box.connect('save-as', self.save_file_as)
+                self.toolbar_box.connect('new-file', self.new)
+                self.toolbar_box.connect('pep8-check', self.pep8_check)
+                self.toolbar_box.connect('insert-datetime', self.editor._insert_date_time)
+                self.toolbar_box.connect('copy', self.editor._copy_cb)
+                self.toolbar_box.connect('paste', self.editor._paste_cb)
+                self.toolbar_box.connect('undo', self.editor._undo_cb)
+                self.toolbar_box.connect('redo', self.editor._redo_cb)
+                self.toolbar_box.connect('cut', self.editor._cut_cb)
+                self.toolbar_box.connect('search-text', self._search_text)
+                self.toolbar_box.connect('search-prev', self.editor._search_prev_cb)
+                self.toolbar_box.connect('search-next', self.editor._search_next_cb)
+                self.toolbar_box.connect('show-line-numbers', self.editor._set_show_line_numbers)
+                self.toolbar_box.connect('language-changed', self.change_language)
+                self.toolbar_box.connect('style-changed', self.change_style)
+                self.toolbar_box.connect('font-changed', self.change_font)
+                self.toolbar_box.show_all()
+                self.set_toolbar_box(self.toolbar_box)
                 
                 # Barra de estado de PEP8 / PEP8 status bar
-                self.pep8 = PEP8_Check(self)
+                self.pep8 = PEP8_Check()
                 
                 self.pep8_bar = gtk.Statusbar()
-                #self.pep8.connect("show-bar", (lambda w, bar: bar.show_all()), self.pep8_bar)
-                #self.pep8.connect("hide-bar", (lambda w, bar: bar.hide()), self.pep8_bar)
+                self.pep8.connect("show-bar", (lambda w, bar: bar.show_all()), self.pep8_bar)
+                self.pep8.connect("hide-bar", (lambda w, bar: bar.hide()), self.pep8_bar)
                 self.pep8_bar.label = gtk.Label()
-                #self.pep8.connect("bar-text", (lambda w, t, l: l.set_text(t)), self.pep8_bar.label)
+                self.pep8.connect("bar-text", (lambda w, t, l: l.set_text(t)), self.pep8_bar.label)
                 self.pep8_bar.add(self.pep8_bar.label)
                 vbox.pack_end(self.pep8_bar, False, True, 0)
-
-                # Preferencias / preferences
-
-                preferences_toolbar = gtk.Toolbar()
-
-                show_line_numbers = ToggleToolButton('show-numbers')
-                show_line_numbers.set_tooltip(_("Show line numbers"))
-
-                show_line_numbers.set_active(True)
-                show_line_numbers.connect("clicked", \
-                                     self.editor._set_show_line_numbers)
-                show_line_numbers.show()
-                preferences_toolbar.insert(show_line_numbers, -1)
-
-                self.editor._make_languages_combo(preferences_toolbar)
-                self.editor.make_style_combo(preferences_toolbar)
-                
-                separator = gtk.SeparatorToolItem()
-                separator.set_draw(False)
-                separator.set_expand(True)
-                preferences_toolbar.insert(separator, -1)
-                separator.show_all()
                 
                 self.python_console = PythonConsole()
-                self.python_console.showed = False
-                vbox.pack_end(self.python_console, False, True, 0)
-                
-                self.python_console.hide()
-                
-                python_console_btn = ToolButton("python-console")
-                python_console_btn.set_tooltip(_("Show or hide the python console"))
-                python_console_btn.connect("clicked", self.show_python_console)
-                preferences_toolbar.insert(python_console_btn, -1)
-                python_console_btn.show_all()
-
-                preferences = ToolbarButton()
-                preferences.props.page = preferences_toolbar
-                preferences.props.icon_name = 'preferences-system'
-                preferences.show_all()
-
-                self.toolbar_box.toolbar.insert(preferences, -1)
-
-                font_options = FontToolbarButton()
-                font_options.connect("load-pango-context",
-                                     self.load_pango_context)
-                font_options.load_toolbar()
-                font_options.connect("font-changed", self.change_font)
-                self.toolbar_box.toolbar.insert(font_options, -1)
-                font_options.show()
-
-                # Separador / Separator
-
-                separator = gtk.SeparatorToolItem()
-                separator.set_draw(False)
-                separator.set_expand(True)
-                self.toolbar_box.toolbar.insert(separator, -1)
-
-                # Boton salir / Stop Button
-
-                exit = StopButton(self)
-                self.toolbar_box.toolbar.insert(exit, -1)
+                self.python_console.show()
+                vpaned.pack2(self.python_console)
+                vpaned.show_all()
+                vbox.show_all()
 
-                self.toolbar_box.show_all()
+        def change_style(self, widget, style):
+                self.editor.set_style(style)
+        
+        def language_changed(self, widget, new_lang):
+                self.toolbar_box.set_active_lang(int(new_lang))
+        
+        def change_language(self, widget, id, language):
+                if id == "python":
+                        self.enable_pep8(None, True)
+                else:
+                        self.enable_pep8(None, False)
+                self.editor.set_language(language)
 
-                self.set_toolbar_box(self.toolbar_box)
-                
         def show_python_console(self, widget):
                 if not self.python_console.showed:
                     self.python_console.show()
@@ -294,12 +142,8 @@ class JAMEdit(activity.Activity):
                     self.python_console.hide()
                     self.python_console.showed = False
 
-        def _search_entry_activate_cb(self, entry):
-                self.editor.set_search_text(entry.props.text)
-                self.update_search_buttons()
-
-        def _search_entry_changed_cb(self, entry):
-                self.editor.set_search_text(entry.props.text)
+        def _search_text(self, widget, text):
+                self.editor.set_search_text(text)
                 self.update_search_buttons()
         
         def update_search_buttons(self):
@@ -315,15 +159,13 @@ class JAMEdit(activity.Activity):
                         self._search_next.props.sensitive = next_result != _1
 
         def enable_pep8(self, widget, active):
-                self.edit_toolbar.pep8_btn.set_visible(active)
-                self.edit_toolbar.pep8_datetime_separator.set_draw(active)
+                self.toolbar_box.set_pep8_sensitive(active)
         
         def change_font(self, widget, family, face, size):
-                self.editor.modify_font(
-               pango.FontDescription("%s %s %d" % (family, face, size)))
-
-        def load_pango_context(self, widget):
-                return self.editor.get_pango_context()
+                self.editor.modify_font(pango.FontDescription("%s %s %d" %
+                                                              (family,
+                                                               face,
+                                                               size)))
 
         def pep8_check(self, widget):
                 self.pep8.check_file(self.editor)
@@ -365,17 +207,15 @@ class JAMEdit(activity.Activity):
                         file.close()
 
         def new(self, widget):
-                self.editor.pep8.check_exit()
+                self.pep8.check_exit(self.editor.get_buffer(), self.editor._get_all_text())
                 _continue = self.save_file(None, type="exit")
                 if _continue:
                         self.metadata["mime_type"] = mime.GENERIC_TYPE_TEXT
                         self.editor.lang = None
                         self.editor.file = None
-                        self.editor.lang_combo.set_active(0)
+                        self.toolbar_box.set_active_lang(0)
                         self.editor.buffer.set_highlight_syntax(False)
-                        self.edit_toolbar.pep8_btn.hide()
-                        self.edit_toolbar.pep8_datetime_separator.set_draw(
-                                                                         False)
+                        self.toolbar_box.set_pep8_sensitive(False)
                         self.editor.buffer.set_text("")
                         self.set_title(_("New"))
 
diff --git a/editor.py b/editor.py
index 16528bb..d9345fc 100644
--- a/editor.py
+++ b/editor.py
@@ -34,20 +34,15 @@ import gtksourceview2
 from sugar.graphics.combobox import ComboBox
 from sugar.graphics.toolcombobox import ToolComboBox
 
-STYLE_MANAGER = gtksourceview2.style_scheme_manager_get_default()
-# Style Files extracted from / Archivos Style extraidos de :
-# http://live.gnome.org/GtkSourceView/StyleSchemes
-STYLE_MANAGER.append_search_path(os.path.join(os.environ["SUGAR_BUNDLE_PATH"],
-                                              "styles"))
-STYLES = STYLE_MANAGER.get_scheme_ids()
 LANGUAGE_MANAGER = gtksourceview2.language_manager_get_default()
-LANGUAGES = LANGUAGE_MANAGER.get_language_ids()
-
 
 class Editor(gtksourceview2.View):
         __gsignals__ = {"pep8-aviable": (gobject.SIGNAL_RUN_LAST,
                                          gobject.TYPE_NONE,
-                                         (gobject.TYPE_BOOLEAN,)),}
+                                         (gobject.TYPE_BOOLEAN,)),
+                        "language-changed": (gobject.SIGNAL_RUN_LAST,
+                                             gobject.TYPE_NONE,
+                                             (gobject.TYPE_STRING,)),}
         def __init__(self):
                 gtksourceview2.View.__init__(self)
 
@@ -74,35 +69,16 @@ class Editor(gtksourceview2.View):
                 self._tagtable.add(self.error_tag)
 
                 self.buffer = gtksourceview2.Buffer(tag_table=self._tagtable)
+                self.buffer.set_highlight_syntax(True)
                 self.set_buffer(self.buffer)
 
                 self.show_all()
 
-        def _set_style(self, widget):
-                name = self.style_combo.get_active()
-                id = STYLES[name]
-                self.buffer.set_style_scheme(STYLE_MANAGER.get_scheme(id))
-
-        def make_style_combo(self, toolbar):
-                self.style_combo = ComboBox()
-                count = 0
-                classic = 0
-                for style in STYLES:
-                        self.style_combo.append_item(None, style.capitalize())
-                        if style == "classic":
-                                classic = count
-                        count += 1
-                self.style_combo.set_active(classic)
-                self.style_combo.connect("changed", self._set_style)
-                tool_item = ToolComboBox(self.style_combo)
-                toolbar.insert(tool_item, -1)
-                tool_item.show_all()
-
-        def _set_show_line_numbers(self, button):
-                if button.get_active():
-                        self.set_show_line_numbers(True)
-                else:
-                        self.set_show_line_numbers(False)
+        def set_style(self, style):
+                self.buffer.set_style_scheme(style)
+
+        def _set_show_line_numbers(self, widget, active):
+                self.set_show_line_numbers(active)
 
         def _copy_cb(self, widget):
                 clipboard = gtk.Clipboard()
@@ -127,37 +103,9 @@ class Editor(gtksourceview2.View):
         def _redo_cb(self, widget):
                 self.buffer.redo()
 
-        def _make_languages_combo(self, toolbar):
-                self.lang_combo = ComboBox()
-                self.lang_combo.append_item(None, _("Plain text"))
-                self.lang_combo.set_active(0)
-
-                for lang in LANGUAGES:
-                        self.lang_combo.append_item(None, lang.capitalize())
-
-                self.lang_combo.connect("changed", self._set_language)
-
-                tool_item = ToolComboBox(self.lang_combo)
-                toolbar.insert(tool_item, -1)
-
-                tool_item.show()
-
-        def _set_language(self, combo):
-                name = self.lang_combo.get_active()
-                if name != 0:
-                        id = LANGUAGES[name - 1]
-                        self.lang = LANGUAGE_MANAGER.get_language(id)
-                        self.buffer.set_highlight_syntax(True)
-                        self.buffer.set_language(self.lang)
-                        if id == "python":
-                                self.emit("pep8-aviable", True)
-                        else:
-                                self.emit("pep8-aviable", False)
-
-                elif name == 0:
-                        self.buffer.set_highlight_syntax(False)
-                        self.lang = None
-                        self.emit("pep8-aviable", False)
+        def set_language(self, lang):
+                self.lang = lang
+                self.buffer.set_language(lang)
 
         def _search_and_active_language(self, mimetype):
                 encontrado = False
@@ -166,11 +114,9 @@ class Editor(gtksourceview2.View):
                         if len(lang.get_mime_types()):
                                 mime = lang.get_mime_types()[0]
                                 if mimetype == mime:
-                                        self.buffer.set_highlight_syntax(True)
                                         self.buffer.set_language(lang)
                                         list_num = LANGUAGES.index(id)
-                                        self.lang_combo.set_active(
-                                                                  list_num + 1)
+                                        self.emit("language-changed", list_num + 1)
                                         encontrado = True
 
                                         if id == "python":
@@ -178,8 +124,8 @@ class Editor(gtksourceview2.View):
                                         else:
                                                 self.emit("pep8-aviable", False)
                 if not encontrado:
-                        self.buffer.set_highlight_syntax(False)
-                        self.lang_combo.set_active(0)
+                        self.buffer.set_language(None)
+                        self.emit("language-changed", 0)
                         self.lang = None
                         self.emit("pep8-aviable", False)
 
@@ -274,4 +220,5 @@ class Editor(gtksourceview2.View):
                         _buffer.place_cursor(start)
 
                         self.scroll_to_iter(start, 0.1)
+
                         self.scroll_to_iter(end, 0.1)
diff --git a/font_options.py b/font_options.py
deleted file mode 100644
index a89aa6b..0000000
--- a/font_options.py
+++ /dev/null
@@ -1,122 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: UTF-8 -*-
-
-#   font_options.py by/por:
-#   Daniel Francis <santiago.danielfrancis@gmail.com>
-#   Agustin Zubiaga <aguzubiaga97@gmail.com>
-#   Sugarlabs - CeibalJAM! - Uruguay
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-import gobject
-import gtk
-
-from sugar.graphics.combobox import ComboBox
-from sugar.graphics.toolcombobox import ToolComboBox
-from sugar.activity.widgets import ToolbarButton
-
-
-class FontToolbarButton(ToolbarButton):
-        __gsignals__ = {'load-pango-context': (gobject.SIGNAL_RUN_LAST,
-                                               gobject.TYPE_PYOBJECT,
-                                               tuple()),
-                        'font-changed': (gobject.SIGNAL_RUN_LAST,
-                                          gobject.TYPE_NONE,
-                                          (gobject.TYPE_STRING,
-                                           gobject.TYPE_STRING,
-                                           gobject.TYPE_INT))}
-
-        def __init__(self):
-                ToolbarButton.__init__(self)
-                self.toolbar = gtk.Toolbar()
-                self.props.page = self.toolbar
-                self.props.icon_name = 'format-text'
-                self.family = "Monospace"
-                self.current_face = "Regular"
-
-        def size_changed(self, adjustment):
-                self.emit("font-changed", self.family,
-                          self.current_face, adjustment.get_value())
-
-        def face_changed(self, widget):
-                iter = widget.get_active_iter()
-                self.current_face = self.faces[self.family].get_value(iter, 0)
-                self.emit('font-changed', self.family,
-                          self.current_face, self.size_adj.get_value())
-
-        def family_changed(self, widget):
-                iter = widget.get_active_iter()
-                self.family = self.family_model.get_value(iter, 0)
-                self.face_combo.set_model(self.faces[self.family])
-                self.face_combo.set_active(0)
-
-        def load_toolbar(self):
-                self.context = self.emit("load-pango-context")
-                self.family_combo = ComboBox()
-                family_renderer = gtk.CellRendererText()
-                family_renderer.set_property("family-set", True)
-                self.family_combo.pack_start(family_renderer)
-                self.family_combo.add_attribute(family_renderer, 'text', 0)
-                self.family_combo.add_attribute(family_renderer, 'family', 0)
-                self.family_model = gtk.ListStore(str)
-                monospace_index = 0
-                count = 0
-                self.faces = {}
-                for i in self.context.list_families():
-                        name = i.get_name()
-                        monospace_index = count if name == "Monospace" else 0
-                        count += 1
-                        self.family_model.append([name])
-                        family_faces = gtk.ListStore(str, str)
-                        for face in i.list_faces():
-                                face_name = face.get_face_name()
-                                family_faces.append([face_name,
-                                                     "%s %s" %
-                                                     (name, face_name)])
-                        self.faces[name] = family_faces
-                self.family_combo.set_model(self.family_model)
-                self.family_combo.set_active(monospace_index)
-                self.family_combo.connect("changed", self.family_changed)
-                self.family_combo.show()
-                self.family_tool_item = ToolComboBox(self.family_combo)
-                self.family_tool_item.show()
-                self.toolbar.insert(self.family_tool_item, -1)
-
-                self.face_combo = ComboBox()
-                face_renderer = gtk.CellRendererText()
-                face_renderer.set_property("family-set", True)
-                self.face_combo.pack_start(face_renderer)
-                self.face_combo.add_attribute(face_renderer, 'text', 0)
-                self.face_combo.add_attribute(face_renderer, 'font', 1)
-                current_model = self.faces["Monospace"]
-                self.face_combo.set_model(current_model)
-                self.face_combo.set_active(0)
-                self.face_combo.connect("changed", self.face_changed)
-                self.face_combo.show()
-                self.face_tool_item = ToolComboBox(self.face_combo)
-                self.face_tool_item.show()
-                self.toolbar.insert(self.face_tool_item, -1)
-
-                self.size_adj = gtk.Adjustment(value=10, lower=5,
-                                               upper=100, step_incr=1)
-                self.size_adj.connect("value-changed", self.size_changed)
-                self.size_spin = gtk.SpinButton(self.size_adj)
-                self.size_spin.show()
-                self.size_spin_item = gtk.ToolItem()
-                self.size_spin_item.add(self.size_spin)
-                self.size_spin_item.show()
-                self.toolbar.insert(self.size_spin_item, -1)
-
-                self.toolbar.show()
diff --git a/options.py b/options.py
new file mode 100644
index 0000000..9a22e09
--- /dev/null
+++ b/options.py
@@ -0,0 +1,477 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#   activity.py by/por:
+#   Agustin Zubiaga <aguzubiaga97@gmail.com>
+#   Daniel Francis <santiago.danielfrancis@gmail.com>
+#   Sugarlabs - CeibalJAM! - Uruguay
+
+#       This program is free software; you can redistribute it and/or modify
+#       it under the terms of the GNU General Public License as published by
+#       the Free Software Foundation; either version 2 of the License, or
+#       (at your option) any later version.
+#       
+#       This program is distributed in the hope that it will be useful,
+#       but WITHOUT ANY WARRANTY; without even the implied warranty of
+#       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#       GNU General Public License for more details.
+#       
+#       You should have received a copy of the GNU General Public License
+#       along with this program; if not, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+#       
+
+import os
+
+import gobject
+import gtk
+
+import gtksourceview2
+STYLE_MANAGER = gtksourceview2.style_scheme_manager_get_default()
+# Style Files extracted from / Archivos Style extraidos de :
+# http://live.gnome.org/GtkSourceView/StyleSchemes
+STYLE_MANAGER.append_search_path(os.path.join(os.environ["SUGAR_BUNDLE_PATH"],
+                                              "styles"))
+STYLES = STYLE_MANAGER.get_scheme_ids()
+LANGUAGE_MANAGER = gtksourceview2.language_manager_get_default()
+LANGUAGES = LANGUAGE_MANAGER.get_language_ids()
+
+from sugar.activity.widgets import EditToolbar, StopButton, \
+                                   ActivityToolbarButton, ToolbarButton
+from sugar.graphics import iconentry
+from sugar.graphics.combobox import ComboBox
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.toggletoolbutton import ToggleToolButton
+from sugar.graphics.toolcombobox import ToolComboBox
+from sugar.graphics.toolbarbox import ToolbarBox
+
+class MainOptions(ActivityToolbarButton):
+        __gsignals__ = {'open-from-journal': (gobject.SIGNAL_RUN_LAST,
+                                              gobject.TYPE_NONE,
+                                              tuple()),
+                        'open-file': (gobject.SIGNAL_RUN_LAST,
+                                      gobject.TYPE_NONE,
+                                      tuple()),
+                        'save-file': (gobject.SIGNAL_RUN_LAST,
+                                      gobject.TYPE_NONE,
+                                      tuple()),
+                        'save-as': (gobject.SIGNAL_RUN_LAST,
+                                    gobject.TYPE_NONE,
+                                    tuple()),
+                        'new-file': (gobject.SIGNAL_RUN_LAST,
+                                     gobject.TYPE_NONE,
+                                     tuple())}
+        def __init__(self, activity):
+                ActivityToolbarButton.__init__(self, activity)
+
+                # Abrir objeto / Open object
+                self.open_obj_btn = ToolButton("open-from-journal")
+                self.open_obj_btn.set_tooltip(_("Open object from journal"))
+                self.open_obj_btn.connect_object("clicked", self.emit, 'open-from-journal')
+                self.page.insert(self.open_obj_btn, -1)
+
+                # Separador / Separator
+                separator = gtk.SeparatorToolItem()
+                separator.set_draw(True)
+                separator.set_expand(False)
+                self.page.insert(separator, -1)
+
+                # Boton de Abrir Archivo / Open File button
+                self.open_btn = ToolButton("fileopen")
+                self.open_btn.set_tooltip(_("Open File"))
+                self.open_btn.set_accelerator('<ctrl>o')
+                self.open_btn.connect_object("clicked", self.emit, 'open-file')
+                self.page.insert(self.open_btn, -1)
+
+                # ****** Save File button ******
+                self.save_btn = ToolButton("stock_save")
+                self.save_btn.set_tooltip(_("Save this file"))
+                self.save_btn.set_accelerator('<ctrl>s')
+                self.save_btn.connect_object("clicked", self.emit, 'save-file')
+                self.page.insert(self.save_btn, -1)
+
+                self.page.show_all()
+                self.page.stop.hide()
+
+                # Guardar como / Save As
+                self.save_as = gtk.MenuItem(_("Save on the file system."))
+                self.page.keep.props.palette.menu.append(self.save_as)
+                self.save_as.connect_object("activate", self.emit, "save-as")
+                self.save_as.show()
+
+                # Nuevo / New
+                self.new = ToolButton("new")
+                self.new.set_tooltip(_("New file"))
+                self.new.set_accelerator('<ctrl>n')
+                self.new.connect_object("clicked", self.emit, 'new-file')
+                self.page.insert(self.new, 6)
+                self.new.show()
+
+                self.page.keep.show()
+
+class EditOptions(ToolbarButton):
+        __gsignals__ = {'pep8-check': (gobject.SIGNAL_RUN_LAST,
+                                       gobject.TYPE_NONE,
+                                       tuple()),
+                        'insert-datetime': (gobject.SIGNAL_RUN_LAST,
+                                            gobject.TYPE_NONE,
+                                            tuple()),
+                        'copy': (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                        'paste': (gobject.SIGNAL_RUN_LAST,
+                                  gobject.TYPE_NONE,
+                                  tuple()),
+                        'undo': (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                        'redo': (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                        'cut': (gobject.SIGNAL_RUN_LAST,
+                                gobject.TYPE_NONE,
+                                tuple())}
+
+        def __init__(self):
+                self._toolbar = EditToolbar()
+                ToolbarButton.__init__(self, label=_("Edit"), page=self._toolbar, icon_name='toolbar-edit')
+
+                self.cut = ToolButton("cut")
+                self.cut.set_tooltip(_("Cut"))
+                self.cut.set_accelerator('<ctrl>x')
+                self._toolbar.insert(self.cut, 4)
+
+                separator = gtk.SeparatorToolItem()
+                separator.set_draw(False)
+                separator.set_expand(True)
+                self._toolbar.insert(separator, -1)
+
+                self.pep8_btn = ToolButton('pep8')
+                self.pep8_btn.set_tooltip(_("PEP 8 Check"))
+                self.pep8_btn.connect_object("clicked", self.emit, 'pep8-check')
+                self._toolbar.insert(self.pep8_btn, -1)
+
+                self.pep8_datetime_separator = gtk.SeparatorToolItem()
+                self.pep8_datetime_separator.set_draw(True)
+                self._toolbar.insert(self.pep8_datetime_separator, -1)
+
+                self.insert_datetime = ToolButton("insert-datetime")
+                self.insert_datetime.connect_object("clicked", self.emit, 'insert-datetime')
+                #                             self.editor._insert_date_time)
+                self.insert_datetime.set_tooltip(_("Insert date and time"))
+                self._toolbar.insert(self.insert_datetime, -1)
+                self.insert_datetime.show_all()
+
+                self._toolbar.copy.connect_object("clicked", self.emit, 'copy')
+                self._toolbar.paste.connect_object("clicked", self.emit, 'paste')
+                self._toolbar.undo.connect_object("clicked", self.emit, 'undo')
+                self._toolbar.redo.connect_object("clicked", self.emit, 'redo')
+                self.cut.connect_object("clicked", self.emit, 'cut')
+
+                self._toolbar.show_all()
+                self.pep8_btn.set_sensitive(False)
+                self.pep8_datetime_separator.set_draw(False)
+        
+        def set_pep8_sensitive(self, sensitive):
+                self.pep8_btn.set_sensitive(sensitive)
+
+class PreferencesOptions(ToolbarButton):
+        __gsignals__ = {'show-line-numbers': (gobject.SIGNAL_RUN_LAST,
+                                              gobject.TYPE_NONE,
+                                              (gobject.TYPE_BOOLEAN,)),
+                        'language-changed': (gobject.SIGNAL_RUN_LAST,
+                                             gobject.TYPE_NONE,
+                                             (gobject.TYPE_STRING,
+                                              gobject.TYPE_PYOBJECT)),
+                        'style-changed': (gobject.SIGNAL_RUN_LAST,
+                                          gobject.TYPE_NONE,
+                                          (gobject.TYPE_PYOBJECT,))}
+        def __init__(self):
+                ToolbarButton.__init__(self)
+                self._toolbar = gtk.Toolbar()
+
+                self.show_line_numbers = ToggleToolButton('show-numbers')
+                self.show_line_numbers.set_tooltip(_("Show line numbers"))
+                self.show_line_numbers.set_active(True)
+                self.show_line_numbers.connect("clicked", (lambda w,s: s.emit('show-line-numbers', w.get_active())), self)
+                #                     self.editor._set_show_line_numbers)
+                self.show_line_numbers.show()
+                self._toolbar.insert(self.show_line_numbers, -1)
+
+                #Languages Combo Box
+                self.lang_combo = ComboBox()
+                self.lang_combo.append_item(None, _("Plain text"))
+                self.lang_combo.set_active(0)
+                for lang in LANGUAGES:
+                        self.lang_combo.append_item(None, lang.capitalize())
+                self.lang_combo.connect("changed", self._lang_changed)
+                self.lang_item = ToolComboBox(self.lang_combo)
+                self._toolbar.insert(self.lang_item, -1)
+                self.lang_item.show()
+
+                self.style_combo = ComboBox()
+                count = 0
+                classic = 0
+                for style in STYLES:
+                        self.style_combo.append_item(None, style.capitalize())
+                        if style == "classic":
+                                classic = count
+                        count += 1
+                self.style_combo.set_active(classic)
+                self.style_combo.connect("changed", (lambda w,s: self.emit('style-changed', STYLE_MANAGER.get_scheme(STYLES[w.get_active()]))), self)
+                self.style_item = ToolComboBox(self.style_combo)
+                self._toolbar.insert(self.style_item, -1)
+                self.style_item.show_all()
+                
+                self.props.page = self._toolbar
+                self.props.icon_name = 'preferences-system'
+
+        def _lang_changed(self, widget):
+                name = widget.get_active()
+                if name != 0:
+                        id = LANGUAGES[name - 1]
+                        lang = LANGUAGE_MANAGER.get_language(id)
+                else:
+                        id = None
+                        lang = None
+                self.emit('language-changed', id, lang)
+        
+        def set_active_lang(self, index):
+                self.lang_combo.set_active(index)
+
+class FontOptions(ToolbarButton):
+        __gsignals__ = {'font-changed': (gobject.SIGNAL_RUN_LAST,
+                                         gobject.TYPE_NONE,
+                                         (gobject.TYPE_STRING,
+                                          gobject.TYPE_STRING,
+                                          gobject.TYPE_INT))}
+
+        def __init__(self, context):
+                ToolbarButton.__init__(self)
+                self.context = context
+                self.toolbar = gtk.Toolbar()
+                self.props.page = self.toolbar
+                self.props.icon_name = 'format-text'
+                self.family = "Monospace"
+                self.current_face = "Regular"
+                self.family_combo = ComboBox()
+                family_renderer = gtk.CellRendererText()
+                family_renderer.set_property("family-set", True)
+                self.family_combo.pack_start(family_renderer)
+                self.family_combo.add_attribute(family_renderer, 'text', 0)
+                self.family_combo.add_attribute(family_renderer, 'family', 0)
+                self.family_model = gtk.ListStore(str)
+                monospace_index = 0
+                count = 0
+                self.faces = {}
+                
+                for i in self.context.list_families():
+                        name = i.get_name()
+                        monospace_index = count if name == "Monospace" else 0
+                        count += 1
+                        self.family_model.append([name])
+                        family_faces = gtk.ListStore(str, str)
+                        for face in i.list_faces():
+                                face_name = face.get_face_name()
+                                family_faces.append([face_name,
+                                                     "%s %s" %
+                                                     (name, face_name)])
+                        self.faces[name] = family_faces
+                self.family_combo.set_model(self.family_model)
+                self.family_combo.set_active(monospace_index)
+                self.family_combo.connect("changed", self.family_changed)
+                self.family_combo.show()
+                self.family_tool_item = ToolComboBox(self.family_combo)
+                self.family_tool_item.show()
+                self.toolbar.insert(self.family_tool_item, -1)
+
+                self.face_combo = ComboBox()
+                face_renderer = gtk.CellRendererText()
+                face_renderer.set_property("family-set", True)
+                self.face_combo.pack_start(face_renderer)
+                self.face_combo.add_attribute(face_renderer, 'text', 0)
+                self.face_combo.add_attribute(face_renderer, 'font', 1)
+                current_model = self.faces["Monospace"]
+                self.face_combo.set_model(current_model)
+                self.face_combo.set_active(0)
+                self.face_combo.connect("changed", self.face_changed)
+                self.face_combo.show()
+                self.face_tool_item = ToolComboBox(self.face_combo)
+                self.face_tool_item.show()
+                self.toolbar.insert(self.face_tool_item, -1)
+
+                self.size_adj = gtk.Adjustment(value=10, lower=5,
+                                               upper=100, step_incr=1)
+                self.size_adj.connect("value-changed", self.size_changed)
+                self.size_spin = gtk.SpinButton(self.size_adj)
+                self.size_spin.show()
+                self.size_spin_item = gtk.ToolItem()
+                self.size_spin_item.add(self.size_spin)
+                self.size_spin_item.show()
+                self.toolbar.insert(self.size_spin_item, -1)
+
+                self.toolbar.show()
+
+        def size_changed(self, adjustment):
+                self.emit("font-changed", self.family,
+                          self.current_face, adjustment.get_value())
+
+        def face_changed(self, widget):
+                iter = widget.get_active_iter()
+                self.current_face = self.faces[self.family].get_value(iter, 0)
+                self.emit('font-changed', self.family,
+                          self.current_face, self.size_adj.get_value())
+
+        def family_changed(self, widget):
+                iter = widget.get_active_iter()
+                self.family = self.family_model.get_value(iter, 0)
+                self.face_combo.set_model(self.faces[self.family])
+                self.face_combo.set_active(0)
+                
+
+class OptionWidget(ToolbarBox):
+        __gsignals__ = {'open-from-journal': (gobject.SIGNAL_RUN_LAST,
+                                              gobject.TYPE_NONE,
+                                              tuple()),
+                        'open-file': (gobject.SIGNAL_RUN_LAST,
+                                      gobject.TYPE_NONE,
+                                      tuple()),
+                        'save-file': (gobject.SIGNAL_RUN_LAST,
+                                      gobject.TYPE_NONE,
+                                      tuple()),
+                        'save-as': (gobject.SIGNAL_RUN_LAST,
+                                    gobject.TYPE_NONE,
+                                    tuple()),
+                        'new-file': (gobject.SIGNAL_RUN_LAST,
+                                     gobject.TYPE_NONE,
+                                     tuple()),
+                        'pep8-check': (gobject.SIGNAL_RUN_LAST,
+                                       gobject.TYPE_NONE,
+                                       tuple()),
+                        'insert-datetime': (gobject.SIGNAL_RUN_LAST,
+                                            gobject.TYPE_NONE,
+                                            tuple()),
+                        'copy': (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                        'paste': (gobject.SIGNAL_RUN_LAST,
+                                  gobject.TYPE_NONE,
+                                  tuple()),
+                        'undo': (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                        'redo': (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                        'cut': (gobject.SIGNAL_RUN_LAST,
+                                gobject.TYPE_NONE,
+                                tuple()),
+                        'search-text': (gobject.SIGNAL_RUN_LAST,
+                                        gobject.TYPE_NONE,
+                                        (gobject.TYPE_STRING,)),
+                        'search-prev': (gobject.SIGNAL_RUN_LAST,
+                                        gobject.TYPE_NONE,
+                                        tuple()),
+                        'search-next': (gobject.SIGNAL_RUN_LAST,
+                                        gobject.TYPE_NONE,
+                                        tuple()),
+                        'show-line-numbers': (gobject.SIGNAL_RUN_LAST,
+                                              gobject.TYPE_NONE,
+                                              (gobject.TYPE_BOOLEAN,)),
+                        'language-changed': (gobject.SIGNAL_RUN_LAST,
+                                             gobject.TYPE_NONE,
+                                             (gobject.TYPE_STRING,
+                                              gobject.TYPE_PYOBJECT)),
+                        'style-changed': (gobject.SIGNAL_RUN_LAST,
+                                          gobject.TYPE_NONE,
+                                          (gobject.TYPE_PYOBJECT,)),
+                        'font-changed': (gobject.SIGNAL_RUN_LAST,
+                                         gobject.TYPE_NONE,
+                                         (gobject.TYPE_STRING,
+                                          gobject.TYPE_STRING,
+                                          gobject.TYPE_INT))}
+        def __init__(self, activity, context):
+                ToolbarBox.__init__(self)
+
+                self.main_options = MainOptions(activity)
+                self.main_options.connect_object('open-from-journal', self.emit, 'open-from-journal')
+                self.main_options.connect_object('open-file', self.emit, 'open-file')
+                self.main_options.connect_object('save-file', self.emit, 'save-file')
+                self.main_options.connect_object('save-as', self.emit, 'save-as')
+                self.main_options.connect_object('new-file', self.emit, 'new-file')
+                self.toolbar.insert(self.main_options, 0)
+
+                self.edit_options = EditOptions()
+                self.edit_options.connect_object('pep8-check', self.emit, 'pep8-check')
+                self.edit_options.connect_object('insert-datetime', self.emit,'insert-datetime')
+                self.edit_options.connect_object('copy', self.emit, 'copy')
+                self.edit_options.connect_object('paste', self.emit, 'paste')
+                self.edit_options.connect_object('undo', self.emit, 'undo')
+                self.edit_options.connect_object('redo', self.emit, 'redo')
+                self.edit_options.connect_object('cut', self.emit, 'cut')
+                self.toolbar.insert(self.edit_options, -1)
+                
+                # Separador / Separator
+                separator = gtk.SeparatorToolItem()
+                separator.set_draw(False)
+                self.toolbar.insert(separator, -1)
+                
+                # Buscar / Search
+                self.search_entry = iconentry.IconEntry()
+                self.search_entry.set_size_request(gtk.gdk.screen_width() / 3, -1)
+                self.search_entry.set_icon_from_name(
+                        iconentry.ICON_ENTRY_PRIMARY, 'system-search')
+                self.search_entry.add_clear_button()
+                self.search_entry.connect('activate', (lambda w,s: self.emit('search-text', w.props.text)), self)
+                #                     self._search_entry_activate_cb)
+                self.search_entry.connect('changed', (lambda w,s: self.emit('search-text', w.props.text)), self)
+                #                     self._search_entry_changed_cb)
+                self.search_item = gtk.ToolItem()
+                self.search_item.add(self.search_entry)
+                self.toolbar.insert(self.search_item, -1)
+
+                self._search_prev = ToolButton('go-previous-paired')
+                self._search_prev.set_tooltip(_('Previous'))
+                self._search_prev.connect_object('clicked', self.emit, 'search-prev')
+                #                          self.editor._search_prev_cb)
+                self.toolbar.insert(self._search_prev, -1)
+
+                self._search_next = ToolButton('go-next-paired')
+                self._search_next.set_tooltip(_('Next'))
+                self._search_next.connect_object('clicked', self.emit, 'search-next')
+                #                          self.editor._search_next_cb)
+                self.toolbar.insert(self._search_next, -1)
+
+                self.preferences_options = PreferencesOptions()
+                self.preferences_options.connect('show-line-numbers', (lambda w,a,s: s.emit('show-line-numbers', a)), self)
+                self.preferences_options.connect('language-changed', (lambda w,i,l,s: s.emit('language-changed', i, l)), self)
+                self.preferences_options.connect('style-changed', (lambda w,st,s: s.emit('style-changed', st)), self)
+                self.preferences_options.show_all()
+                self.toolbar.insert(self.preferences_options, -1)
+
+                self.font_options = FontOptions(context)
+                self.font_options.connect("font-changed", (lambda w,fav,fac,siz,s: s.emit('font-changed', fav, fac, siz)), self)
+                self.toolbar.insert(self.font_options, -1)
+                self.font_options.show()
+
+                # Separador / Separator
+
+                separator = gtk.SeparatorToolItem()
+                separator.set_draw(False)
+                separator.set_expand(True)
+                self.toolbar.insert(separator, -1)
+
+                # Boton salir / Stop Button
+
+                exit = StopButton(activity)
+                self.toolbar.insert(exit, -1)
+                
+                self.set_active_lang = self.preferences_options.set_active_lang
+                self.set_pep8_sensitive = self.edit_options.set_pep8_sensitive
+        
+        def set_search_prev_sensitive(self, sensitive):
+                self._search_prev.set_sensitive(sensitive)
+        
+        def set_search_next_sensitive(self, sensitive):
+                self._search_next.set_sensitive(sensitive)
diff --git a/pep8_check.py b/pep8_check.py
index a48bf43..c240237 100644
--- a/pep8_check.py
+++ b/pep8_check.py
@@ -19,51 +19,56 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-
-import logging
+import gobject
 import gtk
 
-log = logging.getLogger('EditJam')
-log.setLevel(logging.DEBUG)
-logging.basicConfig()
 import commands
 
 
-class PEP8_Check():
-
-    def __init__(self, activity):
-        self.activity = activity
-
-    def check_file(self, text, editor):
+class PEP8_Check(gobject.GObject):
+    __gsignals__ = {"hide-bar": (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                    "show-bar": (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 tuple()),
+                    "bar-text": (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 (gobject.TYPE_STRING,)),}
+    def __init__(self):
+        gobject.GObject.__init__(self)
+
+    def check_file(self, editor):
+        text = editor._get_all_text()
         tmp_file = open("/tmp/jamedit-pep8-chk.py", "w")
         tmp_file.write(text)
         tmp_file.close()
 
         chk = self.get_check()
 
-        self.highlight_errors(editor, chk)
+        self.highlight_errors(text, chk, editor)
 
-    def highlight_errors(self, editor, chk):
-        text = editor._get_all_text()
-        editor.buffer.set_text("")
+    def highlight_errors(self, text, chk, editor):
+        buffer = editor.get_buffer()
+        buffer.set_text("")
         num = 0
         for line in text.split("\n"):
             num += 1
             if str(num) in chk:
-                line_iter = editor.buffer.get_iter_at_line(num + 2)
+                line_iter = buffer.get_iter_at_line(num + 2)
                 if num == len(text.split("\n")) - 1:
-                    editor.buffer.insert_with_tags(line_iter, line, \
-                                                   editor.error_tag)
+                    buffer.insert_with_tags(line_iter, line, \
+                                            editor.error_tag)
                 else:
-                    editor.buffer.insert_with_tags(line_iter, line + "\n", \
-                                                   editor.error_tag)
+                    buffer.insert_with_tags(line_iter, line + "\n", \
+                                            editor.error_tag)
             else:
-                line_iter = editor.buffer.get_iter_at_line(num)
+                line_iter = buffer.get_iter_at_line(num)
                 if num == len(text.split("\n")) - 1:
-                        editor.buffer.insert_with_tags_by_name(line_iter, line)
+                    buffer.insert_with_tags_by_name(line_iter, line)
                 else:
-                        editor.buffer.insert_with_tags_by_name(line_iter, \
-                                                               line + "\n")
+                    buffer.insert_with_tags_by_name(line_iter, \
+                                                           line + "\n")
         editor.connect("move-cursor", self.set_bar_text, chk)
 
     def get_check(self):
@@ -99,25 +104,24 @@ class PEP8_Check():
             this_line_error = check[str(line)]
             char = this_line_error.split(":")[0]
             this_line_error = this_line_error.split(":")[1]
-            self.activity.pep8_bar.label.set_text(
-                                str(line) + ":" + char + " " + this_line_error)
+            self.emit("bar-text",
+                      str(line) + ":" + char + " " + this_line_error)
             print this_line_error
-            self.activity.pep8_bar.show_all()
+            self.emit("show-bar")
         else:
             pass
 
-    def check_exit(self):
-        text = self.activity.editor._get_all_text()
-        self.activity.editor.buffer.set_text("")
-        editor = self.activity.editor
+    def check_exit(self, buffer, text):
+        buffer.set_text("")
         num = 0
         for line in text.split("\n"):
             num += 1
-            line_iter = editor.buffer.get_iter_at_line(num)
+            line_iter = buffer.get_iter_at_line(num)
             if num == len(text.split("\n")) - 1:
-                editor.buffer.insert_with_tags_by_name(line_iter, line)
+                buffer.insert_with_tags_by_name(line_iter, line)
             else:
-                editor.buffer.insert_with_tags_by_name(line_iter, line + "\n")
+                buffer.insert_with_tags_by_name(line_iter, line + "\n")
+
+        self.emit("hide-bar")
+        self.emit("bar-text", "")
 
-        self.activity.pep8_bar.hide()
-        self.activity.pep8_bar.label.set_text("")