Пример #1
0
class TextEditor(KeepNoteEditor):
    def __init__(self, app):
        KeepNoteEditor.__init__(self, app)
        self._app = app
        self._notebook = None

        self._link_picker = None
        self._maxlinks = 10  # maximum number of links to show in link picker

        # state
        self._page = None  # current NoteBookPage
        self._page_scrolls = {}  # remember scroll in each page
        self._page_cursors = {}
        self._textview_io = RichTextIO()

        # textview and its callbacks
        if SourceView:
            self._textview = SourceView(SourceBuffer())
            self._textview.get_buffer().set_highlight_syntax(True)
            # self._textview.set_show_margin(True)
            # self._textview.disable()
        else:
            self._textview = RichTextView(RichTextBuffer(self._app.get_richtext_tag_table()))  # textview
            self._textview.disable()
            self._textview.connect("modified", self._on_modified_callback)
            self._textview.connect("visit-url", self._on_visit_url)

        # scrollbars
        self._sw = gtk.ScrolledWindow()
        self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self._sw.set_shadow_type(gtk.SHADOW_IN)
        self._sw.add(self._textview)
        self.pack_start(self._sw)

        # self._socket = gtk.Socket()
        # self.pack_start(self._socket)

        # menus
        # self.editor_menus = EditorMenus(self._app, self)

        # find dialog
        # self.find_dialog = dialog_find.KeepNoteFindDialog(self)

        self.show_all()

    def set_notebook(self, notebook):
        """Set notebook for editor"""
        # set new notebook
        self._notebook = notebook

        if self._notebook:
            # read default font
            pass
        else:
            # no new notebook, clear the view
            self.clear_view()

    def load_preferences(self, app_pref, first_open=False):
        """Load application preferences"""

        # self.editor_menus.enable_spell_check(
        #    self._app.pref.get("editors", "general", "spell_check",
        #                       default=True))

        if not SourceView:
            self._textview.set_default_font("Monospace 10")

    def save_preferences(self, app_pref):
        """Save application preferences"""
        # record state in preferences
        # app_pref.set("editors", "general", "spell_check",
        #             self._textview.is_spell_check_enabled())

    def get_textview(self):
        """Return the textview"""
        return self._textview

    def is_focus(self):
        """Return True if text editor has focus"""
        return self._textview.is_focus()

    def grab_focus(self):
        """Pass focus to textview"""
        self._textview.grab_focus()

    def clear_view(self):
        """Clear editor view"""
        self._page = None
        if not SourceView:
            self._textview.disable()

    def undo(self):
        """Undo the last action in the viewer"""
        self._textview.undo()

    def redo(self):
        """Redo the last action in the viewer"""
        self._textview.redo()

    def view_nodes(self, nodes):
        """View a page in the editor"""
        # editor cannot view multiple nodes at once
        # if asked to, it will view none
        if len(nodes) > 1:
            nodes = []

        # save current page before changing nodes
        self.save()
        self._save_cursor()

        if len(nodes) == 0:
            self.clear_view()

        else:
            page = nodes[0]
            self._page = page
            if not SourceView:
                self._textview.enable()

            try:
                if page.has_attr("payload_filename"):
                    # text = safefile.open(
                    #    os.path.join(page.get_path(),
                    #                 page.get_attr("payload_filename")),
                    #    codec="utf-8").read()
                    infile = page.open_file(page.get_attr("payload_filename"), "r", "utf-8")
                    text = infile.read()
                    infile.close()
                    self._textview.get_buffer().set_text(text)
                    self._load_cursor()

                    if SourceView:
                        manager = SourceLanguageManager()
                        # print manager.get_language_ids()
                        # lang = manager.get_language_from_mime_type(
                        #    page.get_attr("content_type"))
                        lang = manager.get_language("python")
                        self._textview.get_buffer().set_language(lang)

                else:
                    self.clear_view()

            except RichTextError, e:
                self.clear_view()
                self.emit("error", e.msg, e)
            except Exception, e:
                self.clear_view()
                self.emit("error", "Unknown error", e)
Пример #2
0
class TextEditor(KeepNoteEditor):
    def __init__(self, app):
        KeepNoteEditor.__init__(self, app)
        self._app = app
        self._notebook = None

        # state
        self._page = None  # current NoteBookPage
        self._page_scrolls = {}  # remember scroll in each page
        self._page_cursors = {}
        self._textview_io = RichTextIO()

        # textview and its callbacks
        self._textview = RichTextView(
            RichTextBuffer(self._app.get_richtext_tag_table()))  # textview
        self._textview.disable()
        self._textview.connect("modified", self._on_modified_callback)
        self._textview.connect("visit-url", self._on_visit_url)

        # scrollbars
        self._sw = gtk.ScrolledWindow()
        self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self._sw.set_shadow_type(gtk.SHADOW_IN)
        self._sw.add(self._textview)
        self.pack_start(self._sw)

        #self._socket = gtk.Socket()
        #self.pack_start(self._socket)

        # menus
        self.editor_menus = EditorMenus(self._app, self)

        # find dialog
        self.find_dialog = dialog_find.KeepNoteFindDialog(self)

        self.show_all()

    def set_notebook(self, notebook):
        """Set notebook for editor"""

        # set new notebook
        self._notebook = notebook

        if self._notebook:
            # read default font
            pass
        else:
            # no new notebook, clear the view
            self.clear_view()

    def load_preferences(self, app_pref, first_open=False):
        """Load application preferences"""

        self.editor_menus.enable_spell_check(
            self._app.pref.get(
                "editors", "general", "spell_check", default=True))

        self._textview.set_default_font("Monospace 10")

    def save_preferences(self, app_pref):
        """Save application preferences"""

        # record state in preferences
        app_pref.set("editors", "general", "spell_check",
                     self._textview.is_spell_check_enabled())

    def get_textview(self):
        """Return the textview"""
        return self._textview

    def is_focus(self):
        """Return True if text editor has focus"""
        return self._textview.is_focus()

    def grab_focus(self):
        """Pass focus to textview"""
        self._textview.grab_focus()

    def clear_view(self):
        """Clear editor view"""
        self._page = None
        self._textview.disable()

    def undo(self):
        """Undo the last action in the viewer"""
        self._textview.undo()

    def redo(self):
        """Redo the last action in the viewer"""
        self._textview.redo()

    def view_pages(self, pages):
        """View a page in the editor"""

        # editor cannot view multiple pages at once
        # if asked to, it will view none
        if len(pages) > 1:
            pages = []

        # save current page before changing pages
        self.save()
        self._save_cursor()

        if len(pages) == 0:
            self.clear_view()

        else:
            page = pages[0]
            self._page = page
            self._textview.enable()

            try:
                if page.has_attr("payload_filename"):
                    infile = page.open_file(page.get_attr("payload_filename"))
                    text = infile.read()
                    infile.close()
                    self._textview.get_buffer().set_text(text)
                    self._load_cursor()

                else:
                    self.clear_view()

            except UnicodeDecodeError, e:
                self.clear_view()
            except RichTextError, e:
                self.clear_view()
                self.emit("error", e.msg, e)
            except Exception, e:
                keepnote.log_error()
                self.clear_view()
                self.emit("error", "Unknown error", e)
Пример #3
0
class TextEditor(KeepNoteEditor):
    def __init__(self, app):
        KeepNoteEditor.__init__(self, app)
        self._app = app
        self._notebook = None

        self._link_picker = None
        self._maxlinks = 10  # maximum number of links to show in link picker

        # state
        self._page = None  # current NoteBookPage
        self._page_scrolls = {}  # remember scroll in each page
        self._page_cursors = {}
        self._textview_io = RichTextIO()

        # textview and its callbacks
        if SourceView:
            self._textview = SourceView(SourceBuffer())
            self._textview.get_buffer().set_highlight_syntax(True)
            #self._textview.set_show_margin(True)
            #self._textview.disable()
        else:
            self._textview = RichTextView(
                RichTextBuffer(self._app.get_richtext_tag_table()))  # textview
            self._textview.disable()
            self._textview.connect("modified", self._on_modified_callback)
            self._textview.connect("visit-url", self._on_visit_url)

        # scrollbars
        self._sw = gtk.ScrolledWindow()
        self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self._sw.set_shadow_type(gtk.SHADOW_IN)
        self._sw.add(self._textview)
        self.pack_start(self._sw)

        #self._socket = gtk.Socket()
        #self.pack_start(self._socket)

        # menus
        #self.editor_menus = EditorMenus(self._app, self)

        # find dialog
        #self.find_dialog = dialog_find.KeepNoteFindDialog(self)

        self.show_all()

    def set_notebook(self, notebook):
        """Set notebook for editor"""
        # set new notebook
        self._notebook = notebook

        if self._notebook:
            # read default font
            pass
        else:
            # no new notebook, clear the view
            self.clear_view()

    def load_preferences(self, app_pref, first_open=False):
        """Load application preferences"""

        #self.editor_menus.enable_spell_check(
        #    self._app.pref.get("editors", "general", "spell_check",
        #                       default=True))

        if not SourceView:
            self._textview.set_default_font("Monospace 10")

    def save_preferences(self, app_pref):
        """Save application preferences"""
        # record state in preferences
        #app_pref.set("editors", "general", "spell_check",
        #             self._textview.is_spell_check_enabled())

    def get_textview(self):
        """Return the textview"""
        return self._textview

    def is_focus(self):
        """Return True if text editor has focus"""
        return self._textview.is_focus()

    def grab_focus(self):
        """Pass focus to textview"""
        self._textview.grab_focus()

    def clear_view(self):
        """Clear editor view"""
        self._page = None
        if not SourceView:
            self._textview.disable()

    def undo(self):
        """Undo the last action in the viewer"""
        self._textview.undo()

    def redo(self):
        """Redo the last action in the viewer"""
        self._textview.redo()

    def view_nodes(self, nodes):
        """View a page in the editor"""
        # editor cannot view multiple nodes at once
        # if asked to, it will view none
        if len(nodes) > 1:
            nodes = []

        # save current page before changing nodes
        self.save()
        self._save_cursor()

        if len(nodes) == 0:
            self.clear_view()

        else:
            page = nodes[0]
            self._page = page
            if not SourceView:
                self._textview.enable()

            try:
                if page.has_attr("payload_filename"):
                    #text = safefile.open(
                    #    os.path.join(page.get_path(),
                    #                 page.get_attr("payload_filename")),
                    #    codec="utf-8").read()
                    infile = page.open_file(page.get_attr("payload_filename"),
                                            "r", "utf-8")
                    text = infile.read()
                    infile.close()
                    self._textview.get_buffer().set_text(text)
                    self._load_cursor()

                    if SourceView:
                        manager = SourceLanguageManager()
                        #print manager.get_language_ids()
                        #lang = manager.get_language_from_mime_type(
                        #    page.get_attr("content_type"))
                        lang = manager.get_language("python")
                        self._textview.get_buffer().set_language(lang)

                else:
                    self.clear_view()

            except RichTextError, e:
                self.clear_view()
                self.emit("error", e.msg, e)
            except Exception, e:
                self.clear_view()
                self.emit("error", "Unknown error", e)
Пример #4
0
class TextEditor (KeepNoteEditor):

    def __init__(self, app):
        KeepNoteEditor.__init__(self, app)
        self._app = app
        self._notebook = None                

        # state
        self._page = None                  # current NoteBookPage
        self._page_scrolls = {}            # remember scroll in each page
        self._page_cursors = {}
        self._textview_io = RichTextIO()
        
        
        # textview and its callbacks
        self._textview = RichTextView(RichTextBuffer(
                self._app.get_richtext_tag_table()))    # textview
        self._textview.disable()        
        self._textview.connect("modified", self._on_modified_callback)
        self._textview.connect("visit-url", self._on_visit_url)
        

        # scrollbars
        self._sw = gtk.ScrolledWindow()
        self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self._sw.set_shadow_type(gtk.SHADOW_IN)       
        self._sw.add(self._textview)
        self.pack_start(self._sw)
        
        
        #self._socket = gtk.Socket()
        #self.pack_start(self._socket)
        
        # menus
        self.editor_menus = EditorMenus(self._app, self)

        # find dialog
        self.find_dialog = dialog_find.KeepNoteFindDialog(self)

        self.show_all()


    def set_notebook(self, notebook):
        """Set notebook for editor"""
        
        # set new notebook
        self._notebook = notebook

        if self._notebook:
            # read default font
            pass
        else:
            # no new notebook, clear the view
            self.clear_view()
        
    
    def load_preferences(self, app_pref, first_open=False):
        """Load application preferences"""

        self.editor_menus.enable_spell_check(
            self._app.pref.get("editors", "general", "spell_check",
                               default=True))

        self._textview.set_default_font("Monospace 10")


    def save_preferences(self, app_pref):
        """Save application preferences"""

        # record state in preferences
        app_pref.set("editors", "general", "spell_check", 
                     self._textview.is_spell_check_enabled())


    def get_textview(self):
        """Return the textview"""
        return self._textview
    
        
    def is_focus(self):
        """Return True if text editor has focus"""
        return self._textview.is_focus()

    def grab_focus(self):
        """Pass focus to textview"""
        self._textview.grab_focus()


    def clear_view(self):
        """Clear editor view"""
        self._page = None
        self._textview.disable()
    
    def undo(self):
        """Undo the last action in the viewer"""
        self._textview.undo()

    def redo(self):
        """Redo the last action in the viewer"""
        self._textview.redo()
    
    def view_nodes(self, nodes):
        """View a node(s) in the editor"""
        
        # editor cannot view multiple nodes at once
        # if asked to, it will view none
        if len(nodes) > 1:
            nodes = []

        # save current page before changing nodes
        self.save()
        self._save_cursor()
        
        
        if len(nodes) == 0:            
            self.clear_view()
                
        else:
            page = nodes[0]
            self._page = page
            self._textview.enable()

            try:
                if page.has_attr("payload_filename"):
                    infile = page.open_file(
                        page.get_attr("payload_filename"), "r", "utf-8")
                    text = infile.read()
                    infile.close()
                    self._textview.get_buffer().set_text(text)
                    self._load_cursor()
                    
                else:
                    self.clear_view()

            except UnicodeDecodeError as e:
                self.clear_view()
            except RichTextError as e:
                self.clear_view()                
                self.emit("error", e.msg, e)
            except Exception as e:
                keepnote.log_error()
                self.clear_view()
                self.emit("error", "Unknown error", e)

        if len(nodes) > 0:
            self.emit("view-node", nodes[0])


    def _save_cursor(self):
        if self._page is not None:
            it = self._textview.get_buffer().get_iter_at_mark(
                self._textview.get_buffer().get_insert())
            self._page_cursors[self._page] = it.get_offset()
            
            x, y = self._textview.window_to_buffer_coords(
                gtk.TEXT_WINDOW_TEXT, 0, 0)
            it = self._textview.get_iter_at_location(x, y)
            self._page_scrolls[self._page] = it.get_offset()


    def _load_cursor(self):
        
        # place cursor in last location
        if self._page in self._page_cursors:
            offset = self._page_cursors[self._page]
            it = self._textview.get_buffer().get_iter_at_offset(offset)
            self._textview.get_buffer().place_cursor(it)

        # place scroll in last position
        if self._page in self._page_scrolls:
            offset = self._page_scrolls[self._page]
            buf = self._textview.get_buffer()
            it = buf.get_iter_at_offset(offset)
            mark = buf.create_mark(None, it, True)
            self._textview.scroll_to_mark(mark,
                0.49, use_align=True, xalign=0.0)
            buf.delete_mark(mark)

            
                
    
    def save(self):
        """Save the loaded page"""
        
        if self._page is not None and \
           self._page.is_valid() and \
           self._textview.is_modified():

            try:
                # save text data
                buf = self._textview.get_buffer()
                text = unicode_gtk(buf.get_text(buf.get_start_iter(),
                                                buf.get_end_iter()))
                out = self._page.open_file(
                    self._page.get_attr("payload_filename"), "w", "utf-8")
                out.write(text)
                out.close()
                
                # save meta data            
                self._page.set_attr_timestamp("modified_time")
                self._page.save()

            except RichTextError as e:
                self.emit("error", e.msg, e)

            except NoteBookError as e:
                self.emit("error", e.msg, e)

            except Exception as e:
                self.emit("error", str(e), e)


    def save_needed(self):
        """Returns True if textview is modified"""
        return self._textview.is_modified()
        return False


    def add_ui(self, window):
        self._textview.set_accel_group(window.get_accel_group())
        self._textview.set_accel_path(CONTEXT_MENU_ACCEL_PATH)
        self.editor_menus.add_ui(window)


    def remove_ui(self, window):
        self.editor_menus.remove_ui(window)

    #===========================================
    # callbacks for textview

    def _on_modified_callback(self, textview, modified):
        """Callback for textview modification"""
        self.emit("modified", self._page, modified)
        
        # make notebook node modified
        if modified:
            self._page.mark_modified()
            self._page.notify_change(False)


    def _on_visit_url(self, textview, url):
        """Callback for textview visiting a URL"""

        if is_node_url(url):
            host, nodeid = parse_node_url(url)
            node = self._notebook.get_node_by_id(nodeid)
            if node:
                self.emit("visit-node", node)

        else:
            try:
                self._app.open_webpage(url)
            except KeepNoteError as e:
                self.emit("error", e.msg, e)