[gedit] [snippets] Cleanup imports, unused variables
- From: Jesse van den Kieboom <jessevdk src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gedit] [snippets] Cleanup imports, unused variables
- Date: Sun, 13 Apr 2014 12:17:24 +0000 (UTC)
commit b648027b474f6fc9798edc4c3410177a3d36f91b
Author: Jesse van den Kieboom <jessevdk gmail com>
Date: Sat Apr 12 13:14:16 2014 +0200
[snippets] Cleanup imports, unused variables
plugins/snippets/snippets/__init__.py | 2 +-
plugins/snippets/snippets/appactivatable.py | 106 +-
plugins/snippets/snippets/completion.py | 228 ++--
plugins/snippets/snippets/document.py | 1569 ++++++++++-----------
plugins/snippets/snippets/exporter.py | 132 +-
plugins/snippets/snippets/helper.py | 247 ++--
plugins/snippets/snippets/importer.py | 144 +-
plugins/snippets/snippets/languagemanager.py | 18 +-
plugins/snippets/snippets/library.py | 1477 ++++++++++----------
plugins/snippets/snippets/manager.py | 1728 +++++++++++------------
plugins/snippets/snippets/parser.py | 335 +++---
plugins/snippets/snippets/placeholder.py | 1000 +++++++-------
plugins/snippets/snippets/shareddata.py | 3 +
plugins/snippets/snippets/snippet.py | 619 ++++----
plugins/snippets/snippets/substitutionparser.py | 250 ++--
plugins/snippets/snippets/windowactivatable.py | 218 ++--
16 files changed, 4023 insertions(+), 4053 deletions(-)
---
diff --git a/plugins/snippets/snippets/__init__.py b/plugins/snippets/snippets/__init__.py
index 305d4c8..c161df8 100644
--- a/plugins/snippets/snippets/__init__.py
+++ b/plugins/snippets/snippets/__init__.py
@@ -19,4 +19,4 @@ from .appactivatable import AppActivatable
from .windowactivatable import WindowActivatable
from .document import Document
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/appactivatable.py b/plugins/snippets/snippets/appactivatable.py
index 5542211..aae3686 100644
--- a/plugins/snippets/snippets/appactivatable.py
+++ b/plugins/snippets/snippets/appactivatable.py
@@ -15,39 +15,35 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-import sys
import os
-import shutil
-import gettext
from gi.repository import Gedit, Gtk, Gdk, GObject, Gio, GLib
import platform
from .library import Library
-from .manager import Manager
from .shareddata import SharedData
class AppActivatable(GObject.Object, Gedit.AppActivatable):
- __gtype_name__ = "GeditSnippetsAppActivatable"
+ __gtype_name__ = "GeditSnippetsAppActivatable"
- app = GObject.property(type=Gedit.App)
+ app = GObject.property(type=Gedit.App)
- def __init__(self):
- GObject.Object.__init__(self)
+ def __init__(self):
+ GObject.Object.__init__(self)
- def do_activate(self):
- # Initialize snippets library
- library = Library()
+ def do_activate(self):
+ # Initialize snippets library
+ library = Library()
- if platform.system() == 'Windows':
- snippetsdir = os.path.expanduser('~/gedit/snippets')
- else:
- snippetsdir = os.path.join(GLib.get_user_config_dir(), 'gedit/snippets')
+ if platform.system() == 'Windows':
+ snippetsdir = os.path.expanduser('~/gedit/snippets')
+ else:
+ snippetsdir = os.path.join(GLib.get_user_config_dir(), 'gedit/snippets')
- library.set_dirs(snippetsdir, self.system_dirs())
+ library.set_dirs(snippetsdir, self.system_dirs())
- self.css = Gtk.CssProvider()
- self.css.load_from_data("""
+ self.css = Gtk.CssProvider()
+ self.css.load_from_data("""
.gedit-snippet-manager-paned {
border-style: solid;
border-color: @borders;
@@ -76,55 +72,55 @@ class AppActivatable(GObject.Object, Gedit.AppActivatable):
border-right-width: 0;
}
""".encode('utf-8'))
- Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),
- self.css, 600)
+ Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),
+ self.css, 600)
- action = Gio.SimpleAction(name="snippets")
- action.connect('activate', self.on_action_snippets_activate)
- self.app.add_action(action)
+ action = Gio.SimpleAction(name="snippets")
+ action.connect('activate', self.on_action_snippets_activate)
+ self.app.add_action(action)
- item = Gio.MenuItem.new(_("Manage _Snippets..."), "app.snippets")
- self.menu = self.extend_menu("preferences-section")
- self.menu.append_menu_item(item)
+ item = Gio.MenuItem.new(_("Manage _Snippets..."), "app.snippets")
+ self.menu = self.extend_menu("preferences-section")
+ self.menu.append_menu_item(item)
- def do_deactivate(self):
- self.app.remove_action("snippets")
- self.menu = None
- Gtk.StyleContext.remove_provider_for_screen(Gdk.Screen.get_default(),
- self.css)
+ def do_deactivate(self):
+ self.app.remove_action("snippets")
+ self.menu = None
+ Gtk.StyleContext.remove_provider_for_screen(Gdk.Screen.get_default(),
+ self.css)
- def system_dirs(self):
- if platform.system() != 'Windows':
- if 'XDG_DATA_DIRS' in os.environ:
- datadirs = os.environ['XDG_DATA_DIRS']
- else:
- datadirs = '/usr/local/share' + os.pathsep + '/usr/share'
+ def system_dirs(self):
+ if platform.system() != 'Windows':
+ if 'XDG_DATA_DIRS' in os.environ:
+ datadirs = os.environ['XDG_DATA_DIRS']
+ else:
+ datadirs = '/usr/local/share' + os.pathsep + '/usr/share'
- dirs = []
+ dirs = []
- for d in datadirs.split(os.pathsep):
- d = os.path.join(d, 'gedit', 'plugins', 'snippets')
+ for d in datadirs.split(os.pathsep):
+ d = os.path.join(d, 'gedit', 'plugins', 'snippets')
- if os.path.isdir(d):
- dirs.append(d)
+ if os.path.isdir(d):
+ dirs.append(d)
- dirs.append(self.plugin_info.get_data_dir())
- return dirs
+ dirs.append(self.plugin_info.get_data_dir())
+ return dirs
- def accelerator_activated(self, group, obj, keyval, mod):
- activatable = SharedData().lookup_window_activatable(obj)
+ def accelerator_activated(self, group, obj, keyval, mod):
+ activatable = SharedData().lookup_window_activatable(obj)
- ret = False
+ ret = False
- if activatable:
- ret = activatable.accelerator_activated(keyval, mod)
+ if activatable:
+ ret = activatable.accelerator_activated(keyval, mod)
- return ret
+ return ret
- def create_configure_dialog(self):
- SharedData().show_manager(self.app.get_active_window(), self.plugin_info.get_data_dir())
+ def create_configure_dialog(self):
+ SharedData().show_manager(self.app.get_active_window(), self.plugin_info.get_data_dir())
- def on_action_snippets_activate(self, action, parameter):
- self.create_configure_dialog()
+ def on_action_snippets_activate(self, action, parameter):
+ self.create_configure_dialog()
-# vi:ex:ts=8:et
+# vi:ex:ts=4:et
diff --git a/plugins/snippets/snippets/completion.py b/plugins/snippets/snippets/completion.py
index d48a6a8..55d3a65 100644
--- a/plugins/snippets/snippets/completion.py
+++ b/plugins/snippets/snippets/completion.py
@@ -22,166 +22,166 @@ from .languagemanager import get_language_manager
from .snippet import Snippet
class Proposal(GObject.Object, GtkSource.CompletionProposal):
- __gtype_name__ = "GeditSnippetsProposal"
+ __gtype_name__ = "GeditSnippetsProposal"
- def __init__(self, snippet):
- GObject.Object.__init__(self)
- self._snippet = Snippet(snippet)
+ def __init__(self, snippet):
+ GObject.Object.__init__(self)
+ self._snippet = Snippet(snippet)
- def snippet(self):
- return self._snippet.data
+ def snippet(self):
+ return self._snippet.data
- # Interface implementation
- def do_get_markup(self):
- return self._snippet.display()
+ # Interface implementation
+ def do_get_markup(self):
+ return self._snippet.display()
- def do_get_info(self):
- return self._snippet.data['text']
+ def do_get_info(self):
+ return self._snippet.data['text']
class Provider(GObject.Object, GtkSource.CompletionProvider):
- __gtype_name__ = "GeditSnippetsProvider"
+ __gtype_name__ = "GeditSnippetsProvider"
- def __init__(self, name, language_id, handler):
- GObject.Object.__init__(self)
+ def __init__(self, name, language_id, handler):
+ GObject.Object.__init__(self)
- self.name = name
- self.info_widget = None
- self.proposals = []
- self.language_id = language_id
- self.handler = handler
- self.info_widget = None
- self.mark = None
+ self.name = name
+ self.info_widget = None
+ self.proposals = []
+ self.language_id = language_id
+ self.handler = handler
+ self.info_widget = None
+ self.mark = None
- theme = Gtk.IconTheme.get_default()
- f, w, h = Gtk.icon_size_lookup(Gtk.IconSize.MENU)
+ theme = Gtk.IconTheme.get_default()
+ f, w, h = Gtk.icon_size_lookup(Gtk.IconSize.MENU)
- try:
- self.icon = theme.load_icon(Gtk.STOCK_JUSTIFY_LEFT, w, 0)
- except:
- self.icon = None
+ try:
+ self.icon = theme.load_icon(Gtk.STOCK_JUSTIFY_LEFT, w, 0)
+ except:
+ self.icon = None
- def __del__(self):
- if self.mark:
- self.mark.get_buffer().delete_mark(self.mark)
+ def __del__(self):
+ if self.mark:
+ self.mark.get_buffer().delete_mark(self.mark)
- def set_proposals(self, proposals):
- self.proposals = proposals
+ def set_proposals(self, proposals):
+ self.proposals = proposals
- def mark_position(self, it):
- if not self.mark:
- self.mark = it.get_buffer().create_mark(None, it, True)
- else:
- self.mark.get_buffer().move_mark(self.mark, it)
+ def mark_position(self, it):
+ if not self.mark:
+ self.mark = it.get_buffer().create_mark(None, it, True)
+ else:
+ self.mark.get_buffer().move_mark(self.mark, it)
- def get_word(self, context):
- it = context.get_iter()
+ def get_word(self, context):
+ it = context.get_iter()
- if it.starts_word() or it.starts_line() or not it.ends_word():
- return None
+ if it.starts_word() or it.starts_line() or not it.ends_word():
+ return None
- start = it.copy()
+ start = it.copy()
- if start.backward_word_start():
- self.mark_position(start)
- return start.get_text(it)
- else:
- return None
+ if start.backward_word_start():
+ self.mark_position(start)
+ return start.get_text(it)
+ else:
+ return None
- def do_get_start_iter(self, context, proposal, iter):
- if not self.mark or self.mark.get_deleted():
- return False
+ def do_get_start_iter(self, context, proposal, iter):
+ if not self.mark or self.mark.get_deleted():
+ return False
- iter.assign(self.mark.get_buffer().get_iter_at_mark(self.mark))
+ iter.assign(self.mark.get_buffer().get_iter_at_mark(self.mark))
- return True
+ return True
- def do_match(self, context):
- return True
+ def do_match(self, context):
+ return True
- def get_proposals(self, word):
- if self.proposals:
- proposals = self.proposals
- else:
- proposals = Library().get_snippets(None)
+ def get_proposals(self, word):
+ if self.proposals:
+ proposals = self.proposals
+ else:
+ proposals = Library().get_snippets(None)
- if self.language_id:
- proposals += Library().get_snippets(self.language_id)
+ if self.language_id:
+ proposals += Library().get_snippets(self.language_id)
- # Filter based on the current word
- if word:
- proposals = (x for x in proposals if x['tag'].startswith(word))
+ # Filter based on the current word
+ if word:
+ proposals = (x for x in proposals if x['tag'].startswith(word))
- return [Proposal(x) for x in proposals]
+ return [Proposal(x) for x in proposals]
- def do_populate(self, context):
- proposals = self.get_proposals(self.get_word(context))
- context.add_proposals(self, proposals, True)
+ def do_populate(self, context):
+ proposals = self.get_proposals(self.get_word(context))
+ context.add_proposals(self, proposals, True)
- def do_get_name(self):
- return self.name
+ def do_get_name(self):
+ return self.name
- def do_activate_proposal(self, proposal, piter):
- return self.handler(proposal, piter)
+ def do_activate_proposal(self, proposal, piter):
+ return self.handler(proposal, piter)
- def do_get_info_widget(self, proposal):
- if not self.info_widget:
- view = Gedit.View.new_with_buffer(Gedit.Document())
- manager = get_language_manager()
+ def do_get_info_widget(self, proposal):
+ if not self.info_widget:
+ view = Gedit.View.new_with_buffer(Gedit.Document())
+ manager = get_language_manager()
- lang = manager.get_language('snippets')
- view.get_buffer().set_language(lang)
+ lang = manager.get_language('snippets')
+ view.get_buffer().set_language(lang)
- sw = Gtk.ScrolledWindow()
- sw.add(view)
- sw.show_all()
+ sw = Gtk.ScrolledWindow()
+ sw.add(view)
+ sw.show_all()
- # Fixed size
- sw.set_size_request(300, 200)
+ # Fixed size
+ sw.set_size_request(300, 200)
- self.info_view = view
- self.info_widget = sw
+ self.info_view = view
+ self.info_widget = sw
- return self.info_widget
+ return self.info_widget
- def do_update_info(self, proposal, info):
- buf = self.info_view.get_buffer()
+ def do_update_info(self, proposal, info):
+ buf = self.info_view.get_buffer()
- buf.set_text(proposal.get_info())
- buf.move_mark(buf.get_insert(), buf.get_start_iter())
- buf.move_mark(buf.get_selection_bound(), buf.get_start_iter())
- self.info_view.scroll_to_iter(buf.get_start_iter(), 0.0, False, 0.5, 0.5)
+ buf.set_text(proposal.get_info())
+ buf.move_mark(buf.get_insert(), buf.get_start_iter())
+ buf.move_mark(buf.get_selection_bound(), buf.get_start_iter())
+ self.info_view.scroll_to_iter(buf.get_start_iter(), 0.0, False, 0.5, 0.5)
- def do_get_icon(self):
- return self.icon
+ def do_get_icon(self):
+ return self.icon
- def do_get_activation(self):
- return GtkSource.CompletionActivation.USER_REQUESTED
+ def do_get_activation(self):
+ return GtkSource.CompletionActivation.USER_REQUESTED
class Defaults(GObject.Object, GtkSource.CompletionProvider):
- __gtype_name__ = "GeditSnippetsDefaultsProvider"
+ __gtype_name__ = "GeditSnippetsDefaultsProvider"
- def __init__(self, handler):
- GObject.Object.__init__(self)
+ def __init__(self, handler):
+ GObject.Object.__init__(self)
- self.handler = handler
- self.proposals = []
+ self.handler = handler
+ self.proposals = []
- def set_defaults(self, defaults):
- self.proposals = []
+ def set_defaults(self, defaults):
+ self.proposals = []
- for d in defaults:
- self.proposals.append(GtkSource.CompletionItem.new(d, d, None, None))
+ for d in defaults:
+ self.proposals.append(GtkSource.CompletionItem.new(d, d, None, None))
- def do_get_name(self):
- return ""
+ def do_get_name(self):
+ return ""
- def do_activate_proposal(self, proposal, piter):
- return self.handler(proposal, piter)
+ def do_activate_proposal(self, proposal, piter):
+ return self.handler(proposal, piter)
- def do_populate(self, context):
- context.add_proposals(self, self.proposals, True)
+ def do_populate(self, context):
+ context.add_proposals(self, self.proposals, True)
- def do_get_activation(self):
- return GtkSource.CompletionActivation.NONE
+ def do_get_activation(self):
+ return GtkSource.CompletionActivation.NONE
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/document.py b/plugins/snippets/snippets/document.py
index 27c155c..ab41ecc 100644
--- a/plugins/snippets/snippets/document.py
+++ b/plugins/snippets/snippets/document.py
@@ -18,1067 +18,1062 @@
import os
import re
-from gi.repository import Gtk, Gdk, Gio, GLib, GtkSource, Gedit
+from gi.repository import Gtk, Gdk, Gio, GLib, Gedit, GObject
from .library import Library
from .snippet import Snippet
-from .placeholder import *
+from .placeholder import PlaceholderEnd
from . import completion
from .signals import Signals
from .shareddata import SharedData
from . import helper
class DynamicSnippet(dict):
- def __init__(self, text):
- self['text'] = text
- self.valid = True
+ def __init__(self, text):
+ self['text'] = text
+ self.valid = True
class Document(GObject.Object, Gedit.ViewActivatable, Signals):
- TAB_KEY_VAL = (Gdk.KEY_Tab, Gdk.KEY_ISO_Left_Tab)
- SPACE_KEY_VAL = (Gdk.KEY_space,)
+ TAB_KEY_VAL = (Gdk.KEY_Tab, Gdk.KEY_ISO_Left_Tab)
+ SPACE_KEY_VAL = (Gdk.KEY_space,)
- view = GObject.property(type=Gedit.View)
+ view = GObject.property(type=Gedit.View)
- def __init__(self):
- GObject.Object.__init__(self)
- Signals.__init__(self)
+ def __init__(self):
+ GObject.Object.__init__(self)
+ Signals.__init__(self)
- self.placeholders = []
- self.active_snippets = []
- self.active_placeholder = None
-
- self.ordered_placeholders = []
- self.update_placeholders = []
- self.jump_placeholders = []
- self.language_id = 0
- self.timeout_update_id = 0
-
- self.provider = completion.Provider(_('Snippets'), self.language_id,
self.on_proposal_activated)
- self.defaults_provider = completion.Defaults(self.on_default_activated)
-
- def do_activate(self):
- # Always have a reference to the global snippets
- Library().ref(None)
-
- buf = self.view.get_buffer()
+ self.placeholders = []
+ self.active_snippets = []
+ self.active_placeholder = None
- self.connect_signal(self.view, 'key-press-event', self.on_view_key_press)
- self.connect_signal(buf, 'notify::language', self.on_notify_language)
- self.connect_signal(self.view, 'drag-data-received', self.on_drag_data_received)
+ self.ordered_placeholders = []
+ self.update_placeholders = []
+ self.jump_placeholders = []
+ self.language_id = 0
+ self.timeout_update_id = 0
- self.connect_signal_after(self.view, 'draw', self.on_draw)
+ self.provider = completion.Provider(_('Snippets'), self.language_id, self.on_proposal_activated)
+ self.defaults_provider = completion.Defaults(self.on_default_activated)
- self.update_language()
+ def do_activate(self):
+ # Always have a reference to the global snippets
+ Library().ref(None)
- completion = self.view.get_completion()
+ buf = self.view.get_buffer()
- completion.add_provider(self.provider)
- completion.add_provider(self.defaults_provider)
+ self.connect_signal(self.view, 'key-press-event', self.on_view_key_press)
+ self.connect_signal(buf, 'notify::language', self.on_notify_language)
+ self.connect_signal(self.view, 'drag-data-received', self.on_drag_data_received)
- self.connect_signal(completion, 'hide', self.on_completion_hide)
+ self.connect_signal_after(self.view, 'draw', self.on_draw)
- SharedData().register_controller(self.view, self)
+ self.update_language()
- def do_deactivate(self):
- if self.timeout_update_id != 0:
- GLib.source_remove(self.timeout_update_id)
- self.timeout_update_id = 0
+ completion = self.view.get_completion()
- del self.update_placeholders[:]
- del self.jump_placeholders[:]
+ completion.add_provider(self.provider)
+ completion.add_provider(self.defaults_provider)
- # Always release the reference to the global snippets
- Library().unref(None)
- self.active_placeholder = None
-
- self.disconnect_signals(self.view)
- self.disconnect_signals(self.view.get_buffer())
-
- # Remove all active snippets
- for snippet in list(self.active_snippets):
- self.deactivate_snippet(snippet, True)
+ self.connect_signal(completion, 'hide', self.on_completion_hide)
- completion = self.view.get_completion()
+ SharedData().register_controller(self.view, self)
- if completion:
- completion.remove_provider(self.provider)
- completion.remove_provider(self.defaults_provider)
+ def do_deactivate(self):
+ if self.timeout_update_id != 0:
+ GLib.source_remove(self.timeout_update_id)
+ self.timeout_update_id = 0
- if self.language_id != 0:
- Library().unref(self.language_id)
+ del self.update_placeholders[:]
+ del self.jump_placeholders[:]
- SharedData().unregister_controller(self.view, self)
+ # Always release the reference to the global snippets
+ Library().unref(None)
+ self.active_placeholder = None
- # Call this whenever the language in the view changes. This makes sure that
- # the correct language is used when finding snippets
- def update_language(self):
- lang = self.view.get_buffer().get_language()
+ self.disconnect_signals(self.view)
+ self.disconnect_signals(self.view.get_buffer())
- if lang == None and self.language_id == None:
- return
- elif lang and lang.get_id() == self.language_id:
- return
+ # Remove all active snippets
+ for snippet in list(self.active_snippets):
+ self.deactivate_snippet(snippet, True)
- langid = self.language_id
-
- if lang:
- self.language_id = lang.get_id()
- else:
- self.language_id = None
+ completion = self.view.get_completion()
- if langid != 0:
- Library().unref(langid)
+ if completion:
+ completion.remove_provider(self.provider)
+ completion.remove_provider(self.defaults_provider)
- Library().ref(self.language_id)
- self.provider.language_id = self.language_id
+ if self.language_id != 0:
+ Library().unref(self.language_id)
- SharedData().update_state(self.view.get_toplevel())
+ SharedData().unregister_controller(self.view, self)
- def accelerator_activate(self, keyval, mod):
- if not self.view or not self.view.get_editable():
- return False
+ # Call this whenever the language in the view changes. This makes sure that
+ # the correct language is used when finding snippets
+ def update_language(self):
+ lang = self.view.get_buffer().get_language()
- accelerator = Gtk.accelerator_name(keyval, mod)
- snippets = Library().from_accelerator(accelerator, \
- self.language_id)
+ if lang == None and self.language_id == None:
+ return
+ elif lang and lang.get_id() == self.language_id:
+ return
- if len(snippets) == 0:
- return False
- elif len(snippets) == 1:
- self.apply_snippet(snippets[0])
- else:
- # Do the fancy completion dialog
- self.provider.set_proposals(snippets)
- cm = self.view.get_completion()
- cm.show([self.provider], cm.create_context(None))
+ langid = self.language_id
- return True
+ if lang:
+ self.language_id = lang.get_id()
+ else:
+ self.language_id = None
- def first_snippet_inserted(self):
- buf = self.view.get_buffer()
+ if langid != 0:
+ Library().unref(langid)
- self.connect_signal(buf, 'changed', self.on_buffer_changed)
- self.connect_signal(buf, 'cursor-moved', self.on_buffer_cursor_moved)
- self.connect_signal_after(buf, 'insert-text', self.on_buffer_insert_text)
+ Library().ref(self.language_id)
+ self.provider.language_id = self.language_id
- def last_snippet_removed(self):
- buf = self.view.get_buffer()
- self.disconnect_signal(buf, 'changed')
- self.disconnect_signal(buf, 'cursor-moved')
- self.disconnect_signal(buf, 'insert-text')
+ SharedData().update_state(self.view.get_toplevel())
- def current_placeholder(self):
- buf = self.view.get_buffer()
+ def accelerator_activate(self, keyval, mod):
+ if not self.view or not self.view.get_editable():
+ return False
- piter = buf.get_iter_at_mark(buf.get_insert())
- found = []
+ accelerator = Gtk.accelerator_name(keyval, mod)
+ snippets = Library().from_accelerator(accelerator, \
+ self.language_id)
- for placeholder in self.placeholders:
- begin = placeholder.begin_iter()
- end = placeholder.end_iter()
+ if len(snippets) == 0:
+ return False
+ elif len(snippets) == 1:
+ self.apply_snippet(snippets[0])
+ else:
+ # Do the fancy completion dialog
+ self.provider.set_proposals(snippets)
+ cm = self.view.get_completion()
+ cm.show([self.provider], cm.create_context(None))
- if piter.compare(begin) >= 0 and piter.compare(end) <= 0:
- found.append(placeholder)
+ return True
- if self.active_placeholder in found:
- return self.active_placeholder
- elif len(found) > 0:
- return found[0]
- else:
- return None
+ def first_snippet_inserted(self):
+ buf = self.view.get_buffer()
- def advance_placeholder(self, direction):
- # Returns (CurrentPlaceholder, NextPlaceholder), depending on direction
- buf = self.view.get_buffer()
+ self.connect_signal(buf, 'changed', self.on_buffer_changed)
+ self.connect_signal(buf, 'cursor-moved', self.on_buffer_cursor_moved)
+ self.connect_signal_after(buf, 'insert-text', self.on_buffer_insert_text)
- piter = buf.get_iter_at_mark(buf.get_insert())
- found = current = next = None
- length = len(self.placeholders)
+ def last_snippet_removed(self):
+ buf = self.view.get_buffer()
+ self.disconnect_signal(buf, 'changed')
+ self.disconnect_signal(buf, 'cursor-moved')
+ self.disconnect_signal(buf, 'insert-text')
- placeholders = list(self.placeholders)
+ def current_placeholder(self):
+ buf = self.view.get_buffer()
- if self.active_placeholder:
- begin = self.active_placeholder.begin_iter()
- end = self.active_placeholder.end_iter()
+ piter = buf.get_iter_at_mark(buf.get_insert())
+ found = []
+
+ for placeholder in self.placeholders:
+ begin = placeholder.begin_iter()
+ end = placeholder.end_iter()
+
+ if piter.compare(begin) >= 0 and piter.compare(end) <= 0:
+ found.append(placeholder)
+
+ if self.active_placeholder in found:
+ return self.active_placeholder
+ elif len(found) > 0:
+ return found[0]
+ else:
+ return None
+
+ def advance_placeholder(self, direction):
+ # Returns (CurrentPlaceholder, NextPlaceholder), depending on direction
+ buf = self.view.get_buffer()
+
+ piter = buf.get_iter_at_mark(buf.get_insert())
+ found = current = next = None
+ length = len(self.placeholders)
+
+ placeholders = list(self.placeholders)
+
+ if self.active_placeholder:
+ begin = self.active_placeholder.begin_iter()
+ end = self.active_placeholder.end_iter()
+
+ if piter.compare(begin) >= 0 and piter.compare(end) <= 0:
+ current = self.active_placeholder
+ currentIndex = placeholders.index(self.active_placeholder)
+
+ if direction == 1:
+ # w = piter, x = begin, y = end, z = found
+ nearest = lambda w, x, y, z: (w.compare(x) <= 0 and (not z or \
+ x.compare(z.begin_iter()) < 0))
+ indexer = lambda x: x < length - 1
+ else:
+ # w = piter, x = begin, y = end, z = prev
+ nearest = lambda w, x, y, z: (w.compare(x) >= 0 and (not z or \
+ x.compare(z.begin_iter()) >= 0))
+ indexer = lambda x: x > 0
+
+ for index in range(0, length):
+ placeholder = placeholders[index]
+ begin = placeholder.begin_iter()
+ end = placeholder.end_iter()
+
+ # Find the nearest placeholder
+ if nearest(piter, begin, end, found):
+ found = placeholder
+
+ # Find the current placeholder
+ if piter.compare(begin) >= 0 and \
+ piter.compare(end) <= 0 and \
+ current == None:
+ currentIndex = index
+ current = placeholder
+
+ if current and current != found and \
+ (current.begin_iter().compare(found.begin_iter()) == 0 or \
+ current.end_iter().compare(found.begin_iter()) == 0) and \
+ self.active_placeholder and \
+ current.begin_iter().compare(self.active_placeholder.begin_iter()) == 0:
+ # if current and found are at the same place, then
+ # resolve the 'hugging' problem
+ current = self.active_placeholder
+ currentIndex = placeholders.index(current)
- if piter.compare(begin) >= 0 and piter.compare(end) <= 0:
- current = self.active_placeholder
- currentIndex = placeholders.index(self.active_placeholder)
+ if current:
+ if indexer(currentIndex):
+ next = placeholders[currentIndex + direction]
+ elif found:
+ next = found
+ elif length > 0:
+ next = self.placeholders[0]
- if direction == 1:
- # w = piter, x = begin, y = end, z = found
- nearest = lambda w, x, y, z: (w.compare(x) <= 0 and (not z or \
- x.compare(z.begin_iter()) < 0))
- indexer = lambda x: x < length - 1
- else:
- # w = piter, x = begin, y = end, z = prev
- nearest = lambda w, x, y, z: (w.compare(x) >= 0 and (not z or \
- x.compare(z.begin_iter()) >= 0))
- indexer = lambda x: x > 0
-
- for index in range(0, length):
- placeholder = placeholders[index]
- begin = placeholder.begin_iter()
- end = placeholder.end_iter()
-
- # Find the nearest placeholder
- if nearest(piter, begin, end, found):
- foundIndex = index
- found = placeholder
+ return current, next
- # Find the current placeholder
- if piter.compare(begin) >= 0 and \
- piter.compare(end) <= 0 and \
- current == None:
- currentIndex = index
- current = placeholder
+ def next_placeholder(self):
+ return self.advance_placeholder(1)
- if current and current != found and \
- (current.begin_iter().compare(found.begin_iter()) == 0 or \
- current.end_iter().compare(found.begin_iter()) == 0) and \
- self.active_placeholder and \
- current.begin_iter().compare(self.active_placeholder.begin_iter()) == 0:
- # if current and found are at the same place, then
- # resolve the 'hugging' problem
- current = self.active_placeholder
- currentIndex = placeholders.index(current)
+ def previous_placeholder(self):
+ return self.advance_placeholder(-1)
- if current:
- if indexer(currentIndex):
- next = placeholders[currentIndex + direction]
- elif found:
- next = found
- elif length > 0:
- next = self.placeholders[0]
+ def cursor_on_screen(self):
+ buf = self.view.get_buffer()
+ self.view.scroll_mark_onscreen(buf.get_insert())
- return current, next
+ def set_active_placeholder(self, placeholder):
+ self.active_placeholder = placeholder
- def next_placeholder(self):
- return self.advance_placeholder(1)
+ def goto_placeholder(self, current, next):
+ last = None
- def previous_placeholder(self):
- return self.advance_placeholder(-1)
+ if current:
+ # Signal this placeholder to end action
+ self.view.get_completion().hide()
+ current.leave()
- def cursor_on_screen(self):
- buf = self.view.get_buffer()
- self.view.scroll_mark_onscreen(buf.get_insert())
+ if current.__class__ == PlaceholderEnd:
+ last = current
- def set_active_placeholder(self, placeholder):
- self.active_placeholder = placeholder
+ self.set_active_placeholder(next)
- def goto_placeholder(self, current, next):
- last = None
+ if next:
+ next.enter()
- if current:
- # Signal this placeholder to end action
- self.view.get_completion().hide()
- current.leave()
+ if next.__class__ == PlaceholderEnd:
+ last = next
+ elif len(next.defaults) > 1 and next.get_text() == next.default:
+ self.defaults_provider.set_defaults(next.defaults)
- if current.__class__ == PlaceholderEnd:
- last = current
+ cm = self.view.get_completion()
+ cm.show([self.defaults_provider], cm.create_context(None))
- self.set_active_placeholder(next)
+ if last:
+ # This is the end of the placeholder, remove the snippet etc
+ for snippet in list(self.active_snippets):
+ if snippet.placeholders[0] == last:
+ self.deactivate_snippet(snippet)
+ break
- if next:
- next.enter()
+ self.cursor_on_screen()
- if next.__class__ == PlaceholderEnd:
- last = next
- elif len(next.defaults) > 1 and next.get_text() == next.default:
- self.defaults_provider.set_defaults(next.defaults)
+ return next != None
- cm = self.view.get_completion()
- cm.show([self.defaults_provider], cm.create_context(None))
+ def skip_to_next_placeholder(self):
+ (current, next) = self.next_placeholder()
+ return self.goto_placeholder(current, next)
- if last:
- # This is the end of the placeholder, remove the snippet etc
- for snippet in list(self.active_snippets):
- if snippet.placeholders[0] == last:
- self.deactivate_snippet(snippet)
- break
+ def skip_to_previous_placeholder(self):
+ (current, prev) = self.previous_placeholder()
+ return self.goto_placeholder(current, prev)
- self.cursor_on_screen()
+ def string_in_native_doc_encoding(self, buf, s):
+ enc = buf.get_encoding()
- return next != None
+ if not enc or enc.get_charset() == 'UTF-8':
+ return s
- def skip_to_next_placeholder(self):
- (current, next) = self.next_placeholder()
- return self.goto_placeholder(current, next)
+ try:
+ cv = GLib.convert(s, -1, enc.get_charset(), 'UTF-8')
+ return cv[0]
+ except GLib.GError:
+ pass
- def skip_to_previous_placeholder(self):
- (current, prev) = self.previous_placeholder()
- return self.goto_placeholder(current, prev)
+ return s
- def string_in_native_doc_encoding(self, buf, s):
- enc = buf.get_encoding()
+ def env_get_selected_text(self, buf):
+ bounds = buf.get_selection_bounds()
- if not enc or enc.get_charset() == 'UTF-8':
- return s
+ if bounds:
+ u8 = buf.get_text(bounds[0], bounds[1], False)
- try:
- cv = GLib.convert(s, -1, enc.get_charset(), 'UTF-8')
- return cv[0]
- except GLib.GError:
- pass
+ return {'utf8': u8, 'noenc': self.string_in_native_doc_encoding(buf, u8)}
+ else:
+ return ''
- return s
+ def env_get_current_word(self, buf):
+ start, end = helper.buffer_word_boundary(buf)
- def env_get_selected_text(self, buf):
- bounds = buf.get_selection_bounds()
+ u8 = buf.get_text(start, end, False)
- if bounds:
- u8 = buf.get_text(bounds[0], bounds[1], False)
+ return {'utf8': u8, 'noenc': self.string_in_native_doc_encoding(buf, u8)}
- return {'utf8': u8, 'noenc': self.string_in_native_doc_encoding(buf, u8)}
- else:
- return ''
+ def env_get_current_line(self, buf):
+ start, end = helper.buffer_line_boundary(buf)
- def env_get_current_word(self, buf):
- start, end = buffer_word_boundary(buf)
- enc = buf.get_encoding()
+ u8 = buf.get_text(start, end, False)
- u8 = buf.get_text(start, end, False)
+ return {'utf8': u8, 'noenc': self.string_in_native_doc_encoding(buf, u8)}
- return {'utf8': u8, 'noenc': self.string_in_native_doc_encoding(buf, u8)}
+ def env_get_current_line_number(self, buf):
+ start, end = helper.buffer_line_boundary(buf)
- def env_get_current_line(self, buf):
- start, end = buffer_line_boundary(buf)
+ return str(start.get_line() + 1)
- u8 = buf.get_text(start, end, False)
+ def location_uri_for_env(self, location):
+ if not location:
+ return {'utf8': '', 'noenc': ''}
- return {'utf8': u8, 'noenc': self.string_in_native_doc_encoding(buf, u8)}
+ u8 = location.get_parse_name()
- def env_get_current_line_number(self, buf):
- start, end = buffer_line_boundary(buf)
+ if location.has_uri_scheme('file'):
+ u8 = "file://" + u8
- return str(start.get_line() + 1)
+ return {'utf8': u8, 'noenc': location.get_uri()}
- def location_uri_for_env(self, location):
- if not location:
- return {'utf8': '', 'noenc': ''}
+ def location_name_for_env(self, location):
+ if location:
+ try:
+ info = location.query_info("standard::display-name", 0, None)
+ display_name = info.get_display_name()
+ except:
+ display_name = ''
- u8 = location.get_parse_name()
+ return {'utf8': display_name,
+ 'noenc': location.get_basename()}
+ else:
+ return ''
- if location.has_uri_scheme('file'):
- u8 = "file://" + u8
+ def location_scheme_for_env(self, location):
+ if location:
+ return location.get_uri_scheme()
+ else:
+ return ''
- return {'utf8': u8, 'noenc': location.get_uri()}
+ def location_path_for_env(self, location):
+ if location and location.has_uri_scheme('file'):
+ return {'utf8': location.get_parse_name(),
+ 'noenc': location.get_path()}
+ else:
+ return ''
- def location_name_for_env(self, location):
- if location:
- try:
- info = location.query_info("standard::display-name", 0, None)
- display_name = info.get_display_name()
- except:
- display_name = ''
+ def location_dir_for_env(self, location):
+ if location:
+ parent = location.get_parent()
- return {'utf8': display_name,
- 'noenc': location.get_basename()}
- else:
- return ''
+ if parent and parent.has_uri_scheme('file'):
+ return {'utf8': parent.get_parse_name(),
+ 'noenc': parent.get_path()}
- def location_scheme_for_env(self, location):
- if location:
- return location.get_uri_scheme()
- else:
- return ''
+ return ''
- def location_path_for_env(self, location):
- if location and location.has_uri_scheme('file'):
- return {'utf8': location.get_parse_name(),
- 'noenc': location.get_path()}
- else:
- return ''
+ def env_add_for_location(self, environ, location, prefix):
+ parts = {'URI': self.location_uri_for_env,
+ 'NAME': self.location_name_for_env,
+ 'SCHEME': self.location_scheme_for_env,
+ 'PATH': self.location_path_for_env,
+ 'DIR': self.location_dir_for_env}
- def location_dir_for_env(self, location):
- if location:
- parent = location.get_parent()
+ for k in parts:
+ v = parts[k](location)
+ key = prefix + '_' + k
- if parent and parent.has_uri_scheme('file'):
- return {'utf8': parent.get_parse_name(),
- 'noenc': parent.get_path()}
+ if isinstance(v, dict):
+ environ['utf8'][key] = v['utf8']
+ environ['noenc'][key] = v['noenc']
+ else:
+ environ['utf8'][key] = v
+ environ['noenc'][key] = str(v)
- return ''
+ return environ
- def env_add_for_location(self, environ, location, prefix):
- parts = {'URI': self.location_uri_for_env,
- 'NAME': self.location_name_for_env,
- 'SCHEME': self.location_scheme_for_env,
- 'PATH': self.location_path_for_env,
- 'DIR': self.location_dir_for_env}
+ def env_get_document_type(self, buf):
+ typ = buf.get_mime_type()
- for k in parts:
- v = parts[k](location)
- key = prefix + '_' + k
+ if typ:
+ return typ
+ else:
+ return ''
- if isinstance(v, dict):
- environ['utf8'][key] = v['utf8']
- environ['noenc'][key] = v['noenc']
- else:
- environ['utf8'][key] = v
- environ['noenc'][key] = str(v)
+ def env_get_documents_uri(self, buf):
+ toplevel = self.view.get_toplevel()
- return environ
+ documents_uri = {'utf8': [], 'noenc': []}
- def env_get_document_type(self, buf):
- typ = buf.get_mime_type()
+ if isinstance(toplevel, Gedit.Window):
+ for doc in toplevel.get_documents():
+ r = self.location_uri_for_env(doc.get_location())
- if typ:
- return typ
+ if isinstance(r, dict):
+ documents_uri['utf8'].append(r['utf8'])
+ documents_uri['noenc'].append(r['noenc'])
else:
- return ''
-
- def env_get_documents_uri(self, buf):
- toplevel = self.view.get_toplevel()
-
- documents_uri = {'utf8': [], 'noenc': []}
+ documents_uri['utf8'].append(r)
+ documents_uri['noenc'].append(str(r))
- if isinstance(toplevel, Gedit.Window):
- for doc in toplevel.get_documents():
- r = self.location_uri_for_env(doc.get_location())
+ return {'utf8': ' '.join(documents_uri['utf8']),
+ 'noenc': ' '.join(documents_uri['noenc'])}
- if isinstance(r, dict):
- documents_uri['utf8'].append(r['utf8'])
- documents_uri['noenc'].append(r['noenc'])
- else:
- documents_uri['utf8'].append(r)
- documents_uri['noenc'].append(str(r))
+ def env_get_documents_path(self, buf):
+ toplevel = self.view.get_toplevel()
- return {'utf8': ' '.join(documents_uri['utf8']),
- 'noenc': ' '.join(documents_uri['noenc'])}
+ documents_path = {'utf8': [], 'noenc': []}
- def env_get_documents_path(self, buf):
- toplevel = self.view.get_toplevel()
+ if isinstance(toplevel, Gedit.Window):
+ for doc in toplevel.get_documents():
+ r = self.location_path_for_env(doc.get_location())
- documents_path = {'utf8': [], 'noenc': []}
+ if isinstance(r, dict):
+ documents_path['utf8'].append(r['utf8'])
+ documents_path['noenc'].append(r['noenc'])
+ else:
+ documents_path['utf8'].append(r)
+ documents_path['noenc'].append(str(r))
- if isinstance(toplevel, Gedit.Window):
- for doc in toplevel.get_documents():
- r = self.location_path_for_env(doc.get_location())
+ return {'utf8': ' '.join(documents_path['utf8']),
+ 'noenc': ' '.join(documents_path['noenc'])}
- if isinstance(r, dict):
- documents_path['utf8'].append(r['utf8'])
- documents_path['noenc'].append(r['noenc'])
- else:
- documents_path['utf8'].append(r)
- documents_path['noenc'].append(str(r))
+ def get_environment(self):
+ buf = self.view.get_buffer()
+ environ = {'utf8': {}, 'noenc': {}}
- return {'utf8': ' '.join(documents_path['utf8']),
- 'noenc': ' '.join(documents_path['noenc'])}
+ for k in os.environ:
+ # Get the original environment, as utf-8
+ v = os.environ[k]
+ environ['noenc'][k] = v
+ environ['utf8'][k] = os.environ[k].encode('utf-8')
- def get_environment(self):
- buf = self.view.get_buffer()
- environ = {'utf8': {}, 'noenc': {}}
+ variables = {'GEDIT_SELECTED_TEXT': self.env_get_selected_text,
+ 'GEDIT_CURRENT_WORD': self.env_get_current_word,
+ 'GEDIT_CURRENT_LINE': self.env_get_current_line,
+ 'GEDIT_CURRENT_LINE_NUMBER': self.env_get_current_line_number,
+ 'GEDIT_CURRENT_DOCUMENT_TYPE': self.env_get_document_type,
+ 'GEDIT_DOCUMENTS_URI': self.env_get_documents_uri,
+ 'GEDIT_DOCUMENTS_PATH': self.env_get_documents_path}
- for k in os.environ:
- # Get the original environment, as utf-8
- v = os.environ[k]
- environ['noenc'][k] = v
- environ['utf8'][k] = os.environ[k].encode('utf-8')
+ for var in variables:
+ v = variables[var](buf)
- variables = {'GEDIT_SELECTED_TEXT': self.env_get_selected_text,
- 'GEDIT_CURRENT_WORD': self.env_get_current_word,
- 'GEDIT_CURRENT_LINE': self.env_get_current_line,
- 'GEDIT_CURRENT_LINE_NUMBER': self.env_get_current_line_number,
- 'GEDIT_CURRENT_DOCUMENT_TYPE': self.env_get_document_type,
- 'GEDIT_DOCUMENTS_URI': self.env_get_documents_uri,
- 'GEDIT_DOCUMENTS_PATH': self.env_get_documents_path}
+ if isinstance(v, dict):
+ environ['utf8'][var] = v['utf8']
+ environ['noenc'][var] = v['noenc']
+ else:
+ environ['utf8'][var] = v
+ environ['noenc'][var] = str(v)
- for var in variables:
- v = variables[var](buf)
+ self.env_add_for_location(environ, buf.get_location(), 'GEDIT_CURRENT_DOCUMENT')
- if isinstance(v, dict):
- environ['utf8'][var] = v['utf8']
- environ['noenc'][var] = v['noenc']
- else:
- environ['utf8'][var] = v
- environ['noenc'][var] = str(v)
+ return environ
- self.env_add_for_location(environ, buf.get_location(), 'GEDIT_CURRENT_DOCUMENT')
+ def uses_current_word(self, snippet):
+ matches = re.findall('(\\\\*)\\$GEDIT_CURRENT_WORD', snippet['text'])
- return environ
+ for match in matches:
+ if len(match) % 2 == 0:
+ return True
- def uses_current_word(self, snippet):
- matches = re.findall('(\\\\*)\\$GEDIT_CURRENT_WORD', snippet['text'])
+ return False
- for match in matches:
- if len(match) % 2 == 0:
- return True
+ def uses_current_line(self, snippet):
+ matches = re.findall('(\\\\*)\\$GEDIT_CURRENT_LINE', snippet['text'])
- return False
+ for match in matches:
+ if len(match) % 2 == 0:
+ return True
- def uses_current_line(self, snippet):
- matches = re.findall('(\\\\*)\\$GEDIT_CURRENT_LINE', snippet['text'])
+ return False
- for match in matches:
- if len(match) % 2 == 0:
- return True
+ def apply_snippet(self, snippet, start = None, end = None, environ = {}):
+ if not snippet.valid:
+ return False
- return False
+ # Set environmental variables
+ env = self.get_environment()
- def apply_snippet(self, snippet, start = None, end = None, environ = {}):
- if not snippet.valid:
- return False
+ if environ:
+ for k in environ['utf8']:
+ env['utf8'][k] = environ['utf8'][k]
- # Set environmental variables
- env = self.get_environment()
+ for k in environ['noenc']:
+ env['noenc'][k] = environ['noenc'][k]
- if environ:
- for k in environ['utf8']:
- env['utf8'][k] = environ['utf8'][k]
+ buf = self.view.get_buffer()
+ s = Snippet(snippet, env)
- for k in environ['noenc']:
- env['noenc'][k] = environ['noenc'][k]
+ if not start:
+ start = buf.get_iter_at_mark(buf.get_insert())
- buf = self.view.get_buffer()
- s = Snippet(snippet, env)
+ if not end:
+ end = buf.get_iter_at_mark(buf.get_selection_bound())
- if not start:
- start = buf.get_iter_at_mark(buf.get_insert())
+ if start.equal(end) and self.uses_current_word(s):
+ # There is no tab trigger and no selection and the snippet uses
+ # the current word. Set start and end to the word boundary so that
+ # it will be removed
+ start, end = helper.buffer_word_boundary(buf)
+ elif start.equal(end) and self.uses_current_line(s):
+ # There is no tab trigger and no selection and the snippet uses
+ # the current line. Set start and end to the line boundary so that
+ # it will be removed
+ start, end = helper.buffer_line_boundary(buf)
- if not end:
- end = buf.get_iter_at_mark(buf.get_selection_bound())
+ # You know, we could be in an end placeholder
+ (current, next) = self.next_placeholder()
+ if current and current.__class__ == PlaceholderEnd:
+ self.goto_placeholder(current, None)
- if start.equal(end) and self.uses_current_word(s):
- # There is no tab trigger and no selection and the snippet uses
- # the current word. Set start and end to the word boundary so that
- # it will be removed
- start, end = buffer_word_boundary(buf)
- elif start.equal(end) and self.uses_current_line(s):
- # There is no tab trigger and no selection and the snippet uses
- # the current line. Set start and end to the line boundary so that
- # it will be removed
- start, end = buffer_line_boundary(buf)
+ buf.begin_user_action()
- # You know, we could be in an end placeholder
- (current, next) = self.next_placeholder()
- if current and current.__class__ == PlaceholderEnd:
- self.goto_placeholder(current, None)
+ # Remove the tag, selection or current word
+ buf.delete(start, end)
- buf.begin_user_action()
+ # Insert the snippet
+ if len(self.active_snippets) == 0:
+ self.first_snippet_inserted()
- # Remove the tag, selection or current word
- buf.delete(start, end)
+ sn = s.insert_into(self, start)
+ self.active_snippets.append(sn)
- # Insert the snippet
- holders = len(self.placeholders)
+ # Put cursor at first tab placeholder
+ keys = [x for x in sn.placeholders.keys() if x > 0]
- if len(self.active_snippets) == 0:
- self.first_snippet_inserted()
+ if len(keys) == 0:
+ if 0 in sn.placeholders:
+ self.goto_placeholder(self.active_placeholder, sn.placeholders[0])
+ else:
+ buf.place_cursor(sn.begin_iter())
+ else:
+ self.goto_placeholder(self.active_placeholder, sn.placeholders[keys[0]])
- sn = s.insert_into(self, start)
- self.active_snippets.append(sn)
+ if sn in self.active_snippets:
+ # Check if we can get end_iter in view without moving the
+ # current cursor position out of view
+ cur = buf.get_iter_at_mark(buf.get_insert())
+ last = sn.end_iter()
- # Put cursor at first tab placeholder
- keys = [x for x in sn.placeholders.keys() if x > 0]
+ curloc = self.view.get_iter_location(cur)
+ lastloc = self.view.get_iter_location(last)
- if len(keys) == 0:
- if 0 in sn.placeholders:
- self.goto_placeholder(self.active_placeholder, sn.placeholders[0])
- else:
- buf.place_cursor(sn.begin_iter())
- else:
- self.goto_placeholder(self.active_placeholder, sn.placeholders[keys[0]])
+ if (lastloc.y + lastloc.height) - curloc.y <= \
+ self.view.get_visible_rect().height:
+ self.view.scroll_mark_onscreen(sn.end_mark)
- if sn in self.active_snippets:
- # Check if we can get end_iter in view without moving the
- # current cursor position out of view
- cur = buf.get_iter_at_mark(buf.get_insert())
- last = sn.end_iter()
+ buf.end_user_action()
+ self.view.grab_focus()
- curloc = self.view.get_iter_location(cur)
- lastloc = self.view.get_iter_location(last)
+ return True
- if (lastloc.y + lastloc.height) - curloc.y <= \
- self.view.get_visible_rect().height:
- self.view.scroll_mark_onscreen(sn.end_mark)
+ def get_tab_tag(self, buf, end = None):
+ if not end:
+ end = buf.get_iter_at_mark(buf.get_insert())
- buf.end_user_action()
- self.view.grab_focus()
+ start = end.copy()
+ word = None
+ first = True
- return True
+ # Move start backward as long as there is a valid character
+ while start.backward_char():
+ c = start.get_char()
- def get_tab_tag(self, buf, end = None):
- if not end:
- end = buf.get_iter_at_mark(buf.get_insert())
+ if not helper.is_tab_trigger_character(c):
+ # Check this for a single special char
+ if first and helper.is_tab_trigger(c):
+ break
- start = end.copy()
- word = None
- first = True
+ # Make sure first char is valid
+ while not start.equal(end) and \
+ not helper.is_first_tab_trigger_character(start.get_char()):
+ start.forward_char()
- # Move start backward as long as there is a valid character
- while start.backward_char():
- c = start.get_char()
+ break
- if not helper.is_tab_trigger_character(c):
- # Check this for a single special char
- if first and helper.is_tab_trigger(c):
- break
+ first = False
- # Make sure first char is valid
- while not start.equal(end) and \
- not helper.is_first_tab_trigger_character(start.get_char()):
- start.forward_char()
+ if not start.equal(end):
+ word = buf.get_text(start, end, False)
- break
+ if word and word != '':
+ return (word, start, end)
- first = False
+ return (None, None, None)
- if not start.equal(end):
- word = buf.get_text(start, end, False)
+ def parse_and_run_snippet(self, data, iter):
+ if not self.view.get_editable():
+ return
- if word and word != '':
- return (word, start, end)
+ self.apply_snippet(DynamicSnippet(data), iter, iter)
- return (None, None, None)
+ def run_snippet_trigger(self, trigger, bounds):
+ if not self.view:
+ return False
- def parse_and_run_snippet(self, data, iter):
- if not self.view.get_editable():
- return
+ if not self.view.get_editable():
+ return False
- self.apply_snippet(DynamicSnippet(data), iter, iter)
+ buf = self.view.get_buffer()
- def run_snippet_trigger(self, trigger, bounds):
- if not self.view:
- return False
+ if buf.get_has_selection():
+ return False
- if not self.view.get_editable():
- return False
+ snippets = Library().from_tag(trigger, self.language_id)
- buf = self.view.get_buffer()
+ if snippets:
+ if len(snippets) == 1:
+ return self.apply_snippet(snippets[0], bounds[0], bounds[1])
+ else:
+ # Do the fancy completion dialog
+ self.provider.set_proposals(snippets)
+ cm = self.view.get_completion()
- if buf.get_has_selection():
- return False
+ cm.show([self.provider], cm.create_context(None))
+ return True
- snippets = Library().from_tag(trigger, self.language_id)
+ return False
- if snippets:
- if len(snippets) == 1:
- return self.apply_snippet(snippets[0], bounds[0], bounds[1])
- else:
- # Do the fancy completion dialog
- self.provider.set_proposals(snippets)
- cm = self.view.get_completion()
+ def run_snippet(self):
+ if not self.view:
+ return False
- cm.show([self.provider], cm.create_context(None))
- return True
+ if not self.view.get_editable():
+ return False
- return False
+ buf = self.view.get_buffer()
- def run_snippet(self):
- if not self.view:
- return False
+ # get the word preceding the current insertion position
+ (word, start, end) = self.get_tab_tag(buf)
- if not self.view.get_editable():
- return False
+ if not word:
+ return self.skip_to_next_placeholder()
- buf = self.view.get_buffer()
+ if not self.run_snippet_trigger(word, (start, end)):
+ return self.skip_to_next_placeholder()
+ else:
+ return True
- # get the word preceding the current insertion position
- (word, start, end) = self.get_tab_tag(buf)
+ def deactivate_snippet(self, snippet, force = False):
+ remove = []
+ ordered_remove = []
- if not word:
- return self.skip_to_next_placeholder()
+ for tabstop in snippet.placeholders:
+ if tabstop == -1:
+ placeholders = snippet.placeholders[-1]
+ else:
+ placeholders = [snippet.placeholders[tabstop]]
- if not self.run_snippet_trigger(word, (start, end)):
- return self.skip_to_next_placeholder()
- else:
- return True
+ for placeholder in placeholders:
+ if placeholder in self.placeholders:
+ if placeholder in self.update_placeholders:
+ placeholder.update_contents()
- def deactivate_snippet(self, snippet, force = False):
- buf = self.view.get_buffer()
- remove = []
- ordered_remove = []
+ self.update_placeholders.remove(placeholder)
+ elif placeholder in self.jump_placeholders:
+ placeholder[0].leave()
- for tabstop in snippet.placeholders:
- if tabstop == -1:
- placeholders = snippet.placeholders[-1]
- else:
- placeholders = [snippet.placeholders[tabstop]]
+ remove.append(placeholder)
+ elif placeholder in self.ordered_placeholders:
+ ordered_remove.append(placeholder)
- for placeholder in placeholders:
- if placeholder in self.placeholders:
- if placeholder in self.update_placeholders:
- placeholder.update_contents()
+ for placeholder in remove:
+ if placeholder == self.active_placeholder:
+ self.active_placeholder = None
- self.update_placeholders.remove(placeholder)
- elif placeholder in self.jump_placeholders:
- placeholder[0].leave()
+ self.placeholders.remove(placeholder)
+ self.ordered_placeholders.remove(placeholder)
- remove.append(placeholder)
- elif placeholder in self.ordered_placeholders:
- ordered_remove.append(placeholder)
+ placeholder.remove(force)
- for placeholder in remove:
- if placeholder == self.active_placeholder:
- self.active_placeholder = None
+ for placeholder in ordered_remove:
+ self.ordered_placeholders.remove(placeholder)
+ placeholder.remove(force)
- self.placeholders.remove(placeholder)
- self.ordered_placeholders.remove(placeholder)
+ snippet.deactivate()
+ self.active_snippets.remove(snippet)
- placeholder.remove(force)
+ if len(self.active_snippets) == 0:
+ self.last_snippet_removed()
- for placeholder in ordered_remove:
- self.ordered_placeholders.remove(placeholder)
- placeholder.remove(force)
+ self.view.queue_draw()
- snippet.deactivate()
- self.active_snippets.remove(snippet)
+ def update_snippet_contents(self):
+ self.timeout_update_id = 0
- if len(self.active_snippets) == 0:
- self.last_snippet_removed()
+ for placeholder in self.update_placeholders:
+ placeholder.update_contents()
- self.view.queue_draw()
+ for placeholder in self.jump_placeholders:
+ self.goto_placeholder(placeholder[0], placeholder[1])
- def update_snippet_contents(self):
- self.timeout_update_id = 0
+ del self.update_placeholders[:]
+ del self.jump_placeholders[:]
- for placeholder in self.update_placeholders:
- placeholder.update_contents()
+ return False
- for placeholder in self.jump_placeholders:
- self.goto_placeholder(placeholder[0], placeholder[1])
+ def on_buffer_cursor_moved(self, buf):
+ piter = buf.get_iter_at_mark(buf.get_insert())
- del self.update_placeholders[:]
- del self.jump_placeholders[:]
+ # Check for all snippets if the cursor is outside its scope
+ for snippet in list(self.active_snippets):
+ if snippet.begin_mark.get_deleted() or snippet.end_mark.get_deleted():
+ self.deactivate(snippet)
+ else:
+ begin = snippet.begin_iter()
+ end = snippet.end_iter()
- return False
+ if piter.compare(begin) < 0 or piter.compare(end) > 0:
+ # Oh no! Remove the snippet this instant!!
+ self.deactivate_snippet(snippet)
- def on_buffer_cursor_moved(self, buf):
- piter = buf.get_iter_at_mark(buf.get_insert())
+ current = self.current_placeholder()
- # Check for all snippets if the cursor is outside its scope
- for snippet in list(self.active_snippets):
- if snippet.begin_mark.get_deleted() or snippet.end_mark.get_deleted():
- self.deactivate(snippet)
- else:
- begin = snippet.begin_iter()
- end = snippet.end_iter()
+ if current != self.active_placeholder:
+ self.jump_placeholders.append((self.active_placeholder, current))
- if piter.compare(begin) < 0 or piter.compare(end) > 0:
- # Oh no! Remove the snippet this instant!!
- self.deactivate_snippet(snippet)
+ if self.timeout_update_id == 0:
+ self.timeout_update_id = GLib.timeout_add(0,
+ self.update_snippet_contents)
- current = self.current_placeholder()
+ def on_buffer_changed(self, buf):
+ current = self.current_placeholder()
- if current != self.active_placeholder:
- self.jump_placeholders.append((self.active_placeholder, current))
+ if current:
+ if not current in self.update_placeholders:
+ self.update_placeholders.append(current)
- if self.timeout_update_id == 0:
- self.timeout_update_id = GLib.timeout_add(0,
- self.update_snippet_contents)
+ if self.timeout_update_id == 0:
+ self.timeout_update_id = GLib.timeout_add(0, \
+ self.update_snippet_contents)
- def on_buffer_changed(self, buf):
- current = self.current_placeholder()
+ def on_buffer_insert_text(self, buf, piter, text, length):
+ ctx = helper.get_buffer_context(buf)
- if current:
- if not current in self.update_placeholders:
- self.update_placeholders.append(current)
+ # do nothing special if there is no context and no active
+ # placeholder
+ if (not ctx) and (not self.active_placeholder):
+ return
- if self.timeout_update_id == 0:
- self.timeout_update_id = GLib.timeout_add(0, \
- self.update_snippet_contents)
+ if not ctx:
+ ctx = self.active_placeholder
- def on_buffer_insert_text(self, buf, piter, text, length):
- ctx = get_buffer_context(buf)
+ if not ctx in self.ordered_placeholders:
+ return
- # do nothing special if there is no context and no active
- # placeholder
- if (not ctx) and (not self.active_placeholder):
- return
+ # move any marks that were incorrectly moved by this insertion
+ # back to where they belong
+ begin = ctx.begin_iter()
+ end = ctx.end_iter()
+ idx = self.ordered_placeholders.index(ctx)
- if not ctx:
- ctx = self.active_placeholder
+ for placeholder in self.ordered_placeholders:
+ if placeholder == ctx:
+ continue
- if not ctx in self.ordered_placeholders:
- return
+ ob = placeholder.begin_iter()
+ oe = placeholder.end_iter()
- # move any marks that were incorrectly moved by this insertion
- # back to where they belong
- begin = ctx.begin_iter()
- end = ctx.end_iter()
- idx = self.ordered_placeholders.index(ctx)
+ if ob.compare(begin) == 0 and ((not oe) or oe.compare(end) == 0):
+ oidx = self.ordered_placeholders.index(placeholder)
- for placeholder in self.ordered_placeholders:
- if placeholder == ctx:
- continue
+ if oidx > idx and ob:
+ buf.move_mark(placeholder.begin, end)
+ elif oidx < idx and oe:
+ buf.move_mark(placeholder.end, begin)
+ elif ob.compare(begin) >= 0 and ob.compare(end) < 0 and (oe and oe.compare(end) >= 0):
+ buf.move_mark(placeholder.begin, end)
+ elif (oe and oe.compare(begin) > 0) and ob.compare(begin) <= 0:
+ buf.move_mark(placeholder.end, begin)
- ob = placeholder.begin_iter()
- oe = placeholder.end_iter()
+ def on_notify_language(self, buf, spec):
+ self.update_language()
- if ob.compare(begin) == 0 and ((not oe) or oe.compare(end) == 0):
- oidx = self.ordered_placeholders.index(placeholder)
+ def on_view_key_press(self, view, event):
+ library = Library()
- if oidx > idx and ob:
- buf.move_mark(placeholder.begin, end)
- elif oidx < idx and oe:
- buf.move_mark(placeholder.end, begin)
- elif ob.compare(begin) >= 0 and ob.compare(end) < 0 and (oe and oe.compare(end) >=
0):
- buf.move_mark(placeholder.begin, end)
- elif (oe and oe.compare(begin) > 0) and ob.compare(begin) <= 0:
- buf.move_mark(placeholder.end, begin)
+ state = event.get_state()
- def on_notify_language(self, buf, spec):
- self.update_language()
+ if not self.view.get_editable():
+ return False
- def on_view_key_press(self, view, event):
- library = Library()
+ if not (state & Gdk.ModifierType.CONTROL_MASK) and \
+ not (state & Gdk.ModifierType.MOD1_MASK) and \
+ event.keyval in self.TAB_KEY_VAL:
+ if not state & Gdk.ModifierType.SHIFT_MASK:
+ return self.run_snippet()
+ else:
+ return self.skip_to_previous_placeholder()
+ elif not library.loaded and \
+ library.valid_accelerator(event.keyval, state):
+ library.ensure_files()
+ library.ensure(self.language_id)
+ self.accelerator_activate(event.keyval, \
+ state & Gtk.accelerator_get_default_mod_mask())
- state = event.get_state()
+ return False
- if not self.view.get_editable():
- return False
+ def path_split(self, path, components=[]):
+ head, tail = os.path.split(path)
- if not (state & Gdk.ModifierType.CONTROL_MASK) and \
- not (state & Gdk.ModifierType.MOD1_MASK) and \
- event.keyval in self.TAB_KEY_VAL:
- if not state & Gdk.ModifierType.SHIFT_MASK:
- return self.run_snippet()
- else:
- return self.skip_to_previous_placeholder()
- elif not library.loaded and \
- library.valid_accelerator(event.keyval, state):
- library.ensure_files()
- library.ensure(self.language_id)
- self.accelerator_activate(event.keyval, \
- state & Gtk.accelerator_get_default_mod_mask())
-
- return False
-
- def path_split(self, path, components=[]):
- head, tail = os.path.split(path)
-
- if not tail and head:
- return [head] + components
- elif tail:
- return self.path_split(head, [tail] + components)
- else:
- return components
+ if not tail and head:
+ return [head] + components
+ elif tail:
+ return self.path_split(head, [tail] + components)
+ else:
+ return components
- def apply_uri_snippet(self, snippet, mime, uri):
- # Remove file scheme
- gfile = Gio.file_new_for_uri(uri)
+ def apply_uri_snippet(self, snippet, mime, uri):
+ # Remove file scheme
+ gfile = Gio.file_new_for_uri(uri)
- environ = {'utf8': {'GEDIT_DROP_DOCUMENT_TYPE': mime.encode('utf-8')},
- 'noenc': {'GEDIT_DROP_DOCUMENT_TYPE': mime}}
+ environ = {'utf8': {'GEDIT_DROP_DOCUMENT_TYPE': mime.encode('utf-8')},
+ 'noenc': {'GEDIT_DROP_DOCUMENT_TYPE': mime}}
- self.env_add_for_location(environ, gfile, 'GEDIT_DROP_DOCUMENT')
+ self.env_add_for_location(environ, gfile, 'GEDIT_DROP_DOCUMENT')
- buf = self.view.get_buffer()
- location = buf.get_location()
+ buf = self.view.get_buffer()
+ location = buf.get_location()
- relpath = location.get_relative_path(gfile)
+ relpath = location.get_relative_path(gfile)
- # CHECK: what is the encoding of relpath?
- environ['utf8']['GEDIT_DROP_DOCUMENT_RELATIVE_PATH'] = relpath.encode('utf-8')
- environ['noenc']['GEDIT_DROP_DOCUMENT_RELATIVE_PATH'] = relpath
+ # CHECK: what is the encoding of relpath?
+ environ['utf8']['GEDIT_DROP_DOCUMENT_RELATIVE_PATH'] = relpath.encode('utf-8')
+ environ['noenc']['GEDIT_DROP_DOCUMENT_RELATIVE_PATH'] = relpath
- mark = buf.get_mark('gtk_drag_target')
+ mark = buf.get_mark('gtk_drag_target')
- if not mark:
- mark = buf.get_insert()
+ if not mark:
+ mark = buf.get_insert()
- piter = buf.get_iter_at_mark(mark)
- self.apply_snippet(snippet, piter, piter, environ)
+ piter = buf.get_iter_at_mark(mark)
+ self.apply_snippet(snippet, piter, piter, environ)
- def in_bounds(self, x, y):
- rect = self.view.get_visible_rect()
- rect.x, rect.y = self.view.buffer_to_window_coords(Gtk.TextWindowType.WIDGET, rect.x, rect.y)
+ def in_bounds(self, x, y):
+ rect = self.view.get_visible_rect()
+ rect.x, rect.y = self.view.buffer_to_window_coords(Gtk.TextWindowType.WIDGET, rect.x, rect.y)
- return not (x < rect.x or x > rect.x + rect.width or y < rect.y or y > rect.y + rect.height)
+ return not (x < rect.x or x > rect.x + rect.width or y < rect.y or y > rect.y + rect.height)
- def on_drag_data_received(self, view, context, x, y, data, info, timestamp):
- if not self.view.get_editable():
- return
+ def on_drag_data_received(self, view, context, x, y, data, info, timestamp):
+ if not self.view.get_editable():
+ return
- uris = drop_get_uris(data)
- if not uris:
- return
+ uris = helper.drop_get_uris(data)
+ if not uris:
+ return
- if not self.in_bounds(x, y):
- return
+ if not self.in_bounds(x, y):
+ return
- uris.reverse()
- stop = False
+ uris.reverse()
+ stop = False
- for uri in uris:
- try:
- mime = Gio.content_type_guess(uri)
- except:
- mime = None
+ for uri in uris:
+ try:
+ mime = Gio.content_type_guess(uri)
+ except:
+ mime = None
- if not mime:
- continue
+ if not mime:
+ continue
- snippets = Library().from_drop_target(mime, self.language_id)
+ snippets = Library().from_drop_target(mime, self.language_id)
- if snippets:
- stop = True
- self.apply_uri_snippet(snippets[0], mime, uri)
+ if snippets:
+ stop = True
+ self.apply_uri_snippet(snippets[0], mime, uri)
- if stop:
- context.finish(True, False, timestamp)
- view.stop_emission('drag-data-received')
- view.get_toplevel().present()
- view.grab_focus()
+ if stop:
+ context.finish(True, False, timestamp)
+ view.stop_emission('drag-data-received')
+ view.get_toplevel().present()
+ view.grab_focus()
- def find_uri_target(self, context):
- lst = Gtk.target_list_add_uri_targets((), 0)
+ def find_uri_target(self, context):
+ lst = Gtk.target_list_add_uri_targets((), 0)
- return self.view.drag_dest_find_target(context, lst)
+ return self.view.drag_dest_find_target(context, lst)
- def on_completion_hide(self, completion):
- self.provider.set_proposals(None)
+ def on_completion_hide(self, completion):
+ self.provider.set_proposals(None)
- def on_proposal_activated(self, proposal, piter):
- if not self.view.get_editable():
- return False
+ def on_proposal_activated(self, proposal, piter):
+ if not self.view.get_editable():
+ return False
- buf = self.view.get_buffer()
- bounds = buf.get_selection_bounds()
+ buf = self.view.get_buffer()
+ bounds = buf.get_selection_bounds()
- if bounds:
- self.apply_snippet(proposal.snippet(), None, None)
- else:
- (word, start, end) = self.get_tab_tag(buf, piter)
- self.apply_snippet(proposal.snippet(), start, end)
+ if bounds:
+ self.apply_snippet(proposal.snippet(), None, None)
+ else:
+ (word, start, end) = self.get_tab_tag(buf, piter)
+ self.apply_snippet(proposal.snippet(), start, end)
- return True
+ return True
- def on_default_activated(self, proposal, piter):
- buf = self.view.get_buffer()
- bounds = buf.get_selection_bounds()
+ def on_default_activated(self, proposal, piter):
+ buf = self.view.get_buffer()
+ bounds = buf.get_selection_bounds()
- if bounds:
- buf.begin_user_action()
- buf.delete(bounds[0], bounds[1])
- buf.insert(bounds[0], proposal.props.label)
- buf.end_user_action()
+ if bounds:
+ buf.begin_user_action()
+ buf.delete(bounds[0], bounds[1])
+ buf.insert(bounds[0], proposal.props.label)
+ buf.end_user_action()
- return True
- else:
- return False
+ return True
+ else:
+ return False
- def iter_coords(self, piter):
- rect = self.view.get_iter_location(piter)
- rect.x, rect.y = self.view.buffer_to_window_coords(Gtk.TextWindowType.TEXT, rect.x, rect.y)
+ def iter_coords(self, piter):
+ rect = self.view.get_iter_location(piter)
+ rect.x, rect.y = self.view.buffer_to_window_coords(Gtk.TextWindowType.TEXT, rect.x, rect.y)
- return rect
+ return rect
- def placeholder_in_area(self, placeholder, area):
- start = placeholder.begin_iter()
- end = placeholder.end_iter()
+ def placeholder_in_area(self, placeholder, area):
+ start = placeholder.begin_iter()
+ end = placeholder.end_iter()
- if not start or not end:
- return False
+ if not start or not end:
+ return False
- # Test if start is before bottom, and end is after top
- start_rect = self.iter_coords(start)
- end_rect = self.iter_coords(end)
+ # Test if start is before bottom, and end is after top
+ start_rect = self.iter_coords(start)
+ end_rect = self.iter_coords(end)
- return start_rect.y <= area.y + area.height and \
- end_rect.y + end_rect.height >= area.y
+ return start_rect.y <= area.y + area.height and \
+ end_rect.y + end_rect.height >= area.y
- def draw_placeholder_rect(self, ctx, placeholder):
- start = placeholder.begin_iter()
- start_rect = self.iter_coords(start)
- start_line = start.get_line()
+ def draw_placeholder_rect(self, ctx, placeholder):
+ start = placeholder.begin_iter()
+ start_rect = self.iter_coords(start)
+ start_line = start.get_line()
- end = placeholder.end_iter()
- end_rect = self.iter_coords(end)
- end_line = end.get_line()
+ end = placeholder.end_iter()
+ end_rect = self.iter_coords(end)
+ end_line = end.get_line()
- line = start.copy()
- line.set_line_offset(0)
- geom = self.view.get_window(Gtk.TextWindowType.TEXT).get_geometry()
+ line = start.copy()
+ line.set_line_offset(0)
+ geom = self.view.get_window(Gtk.TextWindowType.TEXT).get_geometry()
- ctx.translate(0.5, 0.5)
+ ctx.translate(0.5, 0.5)
- while line.get_line() <= end_line:
- ypos, height = self.view.get_line_yrange(line)
- x_, ypos = self.view.window_to_buffer_coords(Gtk.TextWindowType.TEXT, 0, ypos)
+ while line.get_line() <= end_line:
+ ypos, height = self.view.get_line_yrange(line)
+ x_, ypos = self.view.window_to_buffer_coords(Gtk.TextWindowType.TEXT, 0, ypos)
- if line.get_line() == start_line and line.get_line() == end_line:
- # Simply draw a box, both are on the same line
- ctx.rectangle(start_rect.x, start_rect.y, end_rect.x - start_rect.x,
start_rect.height - 1)
- ctx.stroke()
- elif line.get_line() == start_line or line.get_line() == end_line:
- if line.get_line() == start_line:
- rect = start_rect
- else:
- rect = end_rect
+ if line.get_line() == start_line and line.get_line() == end_line:
+ # Simply draw a box, both are on the same line
+ ctx.rectangle(start_rect.x, start_rect.y, end_rect.x - start_rect.x, start_rect.height - 1)
+ ctx.stroke()
+ elif line.get_line() == start_line or line.get_line() == end_line:
+ if line.get_line() == start_line:
+ rect = start_rect
+ else:
+ rect = end_rect
- ctx.move_to(0, rect.y + rect.height - 1)
- ctx.rel_line_to(rect.x, 0)
- ctx.rel_line_to(0, -rect.height + 1)
- ctx.rel_line_to(geom[2], 0)
- ctx.stroke()
+ ctx.move_to(0, rect.y + rect.height - 1)
+ ctx.rel_line_to(rect.x, 0)
+ ctx.rel_line_to(0, -rect.height + 1)
+ ctx.rel_line_to(geom[2], 0)
+ ctx.stroke()
- if not line.forward_line():
- break
+ if not line.forward_line():
+ break
- def draw_placeholder_bar(self, ctx, placeholder):
- start = placeholder.begin_iter()
- start_rect = self.iter_coords(start)
+ def draw_placeholder_bar(self, ctx, placeholder):
+ start = placeholder.begin_iter()
+ start_rect = self.iter_coords(start)
- ctx.translate(0.5, 0.5)
- extend_width = 2.5
+ ctx.translate(0.5, 0.5)
+ extend_width = 2.5
- ctx.move_to(start_rect.x - extend_width, start_rect.y)
- ctx.rel_line_to(extend_width * 2, 0)
+ ctx.move_to(start_rect.x - extend_width, start_rect.y)
+ ctx.rel_line_to(extend_width * 2, 0)
- ctx.move_to(start_rect.x, start_rect.y)
- ctx.rel_line_to(0, start_rect.height - 1)
+ ctx.move_to(start_rect.x, start_rect.y)
+ ctx.rel_line_to(0, start_rect.height - 1)
- ctx.rel_move_to(-extend_width, 0)
- ctx.rel_line_to(extend_width * 2, 0)
- ctx.stroke()
+ ctx.rel_move_to(-extend_width, 0)
+ ctx.rel_line_to(extend_width * 2, 0)
+ ctx.stroke()
- def draw_placeholder(self, ctx, placeholder):
- if isinstance(placeholder, PlaceholderEnd):
- return
+ def draw_placeholder(self, ctx, placeholder):
+ if isinstance(placeholder, PlaceholderEnd):
+ return
- col = self.view.get_style_context().get_color(Gtk.StateFlags.INSENSITIVE)
- col.alpha = 0.5
- Gdk.cairo_set_source_rgba(ctx, col)
+ col = self.view.get_style_context().get_color(Gtk.StateFlags.INSENSITIVE)
+ col.alpha = 0.5
+ Gdk.cairo_set_source_rgba(ctx, col)
- if placeholder.tabstop > 0:
- ctx.set_dash([], 0)
- else:
- ctx.set_dash([2], 0)
+ if placeholder.tabstop > 0:
+ ctx.set_dash([], 0)
+ else:
+ ctx.set_dash([2], 0)
- start = placeholder.begin_iter()
- end = placeholder.end_iter()
+ start = placeholder.begin_iter()
+ end = placeholder.end_iter()
- if start.equal(end):
- self.draw_placeholder_bar(ctx, placeholder)
- else:
- self.draw_placeholder_rect(ctx, placeholder)
+ if start.equal(end):
+ self.draw_placeholder_bar(ctx, placeholder)
+ else:
+ self.draw_placeholder_rect(ctx, placeholder)
- def on_draw(self, view, ctx):
- window = view.get_window(Gtk.TextWindowType.TEXT)
+ def on_draw(self, view, ctx):
+ window = view.get_window(Gtk.TextWindowType.TEXT)
- if not Gtk.cairo_should_draw_window(ctx, window):
- return False
+ if not Gtk.cairo_should_draw_window(ctx, window):
+ return False
- # Draw something
- ctx.set_line_width(1.0)
+ # Draw something
+ ctx.set_line_width(1.0)
- Gtk.cairo_transform_to_window(ctx, view, window)
+ Gtk.cairo_transform_to_window(ctx, view, window)
- clipped, clip = Gdk.cairo_get_clip_rectangle(ctx)
+ clipped, clip = Gdk.cairo_get_clip_rectangle(ctx)
- if not clipped:
- return False
+ if not clipped:
+ return False
- for placeholder in self.ordered_placeholders:
- if not self.placeholder_in_area(placeholder, clip):
- continue
+ for placeholder in self.ordered_placeholders:
+ if not self.placeholder_in_area(placeholder, clip):
+ continue
- ctx.save()
- self.draw_placeholder(ctx, placeholder)
- ctx.restore()
+ ctx.save()
+ self.draw_placeholder(ctx, placeholder)
+ ctx.restore()
- return False
+ return False
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/exporter.py b/plugins/snippets/snippets/exporter.py
index 185215e..c99eced 100644
--- a/plugins/snippets/snippets/exporter.py
+++ b/plugins/snippets/snippets/exporter.py
@@ -17,100 +17,98 @@
import os
import tempfile
-import sys
import shutil
-from .library import *
import xml.etree.ElementTree as et
-from .helper import *
+from . import helper
class Exporter:
- def __init__(self, filename, snippets):
- self.filename = filename
- self.set_snippets(snippets)
+ def __init__(self, filename, snippets):
+ self.filename = filename
+ self.set_snippets(snippets)
- def set_snippets(self, snippets):
- self.snippets = {}
+ def set_snippets(self, snippets):
+ self.snippets = {}
- for snippet in snippets:
- lang = snippet.language()
+ for snippet in snippets:
+ lang = snippet.language()
- if lang in self.snippets:
- self.snippets[lang].append(snippet)
- else:
- self.snippets[lang] = [snippet]
+ if lang in self.snippets:
+ self.snippets[lang].append(snippet)
+ else:
+ self.snippets[lang] = [snippet]
- def export_xml(self, dirname, language, snippets):
- # Create the root snippets node
- root = et.Element('snippets')
+ def export_xml(self, dirname, language, snippets):
+ # Create the root snippets node
+ root = et.Element('snippets')
- # Create filename based on language
- if language:
- filename = os.path.join(dirname, language + '.xml')
+ # Create filename based on language
+ if language:
+ filename = os.path.join(dirname, language + '.xml')
- # Set the language attribute
- root.attrib['language'] = language
- else:
- filename = os.path.join(dirname, 'global.xml')
+ # Set the language attribute
+ root.attrib['language'] = language
+ else:
+ filename = os.path.join(dirname, 'global.xml')
- # Add all snippets to the root node
- for snippet in snippets:
- root.append(snippet.to_xml())
+ # Add all snippets to the root node
+ for snippet in snippets:
+ root.append(snippet.to_xml())
- # Write xml
- write_xml(root, filename, ('text', 'accelerator'))
+ # Write xml
+ helper.write_xml(root, filename, ('text', 'accelerator'))
- def export_archive(self, cmd):
- dirname = tempfile.mkdtemp()
+ def export_archive(self, cmd):
+ dirname = tempfile.mkdtemp()
- # Save current working directory and change to temporary directory
- curdir = os.getcwd()
+ # Save current working directory and change to temporary directory
+ curdir = os.getcwd()
- try:
- os.chdir(dirname)
+ try:
+ os.chdir(dirname)
- # Write snippet xml files
- for language, snippets in self.snippets.items():
- self.export_xml(dirname, language , snippets)
+ # Write snippet xml files
+ for language, snippets in self.snippets.items():
+ self.export_xml(dirname, language , snippets)
- # Archive files
- status = os.system('%s "%s" *.xml' % (cmd, self.filename))
- finally:
- os.chdir(curdir)
+ # Archive files
+ status = os.system('%s "%s" *.xml' % (cmd, self.filename))
+ finally:
+ os.chdir(curdir)
- if status != 0:
- return _('The archive "%s" could not be created' % self.filename)
+ if status != 0:
+ return _('The archive "%s" could not be created' % self.filename)
- # Remove the temporary directory
- shutil.rmtree(dirname)
+ # Remove the temporary directory
+ shutil.rmtree(dirname)
- def export_targz(self):
- self.export_archive('tar -c --gzip -f')
+ def export_targz(self):
+ self.export_archive('tar -c --gzip -f')
- def export_tarbz2(self):
- self.export_archive('tar -c --bzip2 -f')
+ def export_tarbz2(self):
+ self.export_archive('tar -c --bzip2 -f')
- def export_tar(self):
- self.export_archive('tar -cf')
+ def export_tar(self):
+ self.export_archive('tar -cf')
- def run(self):
- dirname = os.path.dirname(self.filename)
- if not os.path.exists(dirname):
- return _('Target directory "%s" does not exist') % dirname
+ def run(self):
+ dirname = os.path.dirname(self.filename)
+ if not os.path.exists(dirname):
+ return _('Target directory "%s" does not exist') % dirname
- if not os.path.isdir(dirname):
- return _('Target directory "%s" is not a valid directory') % dirname
+ if not os.path.isdir(dirname):
+ return _('Target directory "%s" is not a valid directory') % dirname
- (root, ext) = os.path.splitext(self.filename)
+ (root, ext) = os.path.splitext(self.filename)
- actions = {'.tar.gz': self.export_targz,
- '.tar.bz2': self.export_tarbz2,
- '.tar': self.export_tar}
+ actions = {'.tar.gz': self.export_targz,
+ '.tar.bz2': self.export_tarbz2,
+ '.tar': self.export_tar}
- for k, v in actions.items():
- if self.filename.endswith(k):
- return v()
+ for k, v in actions.items():
+ if self.filename.endswith(k):
+ return v()
- return self.export_targz()
+ return self.export_targz()
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/helper.py b/plugins/snippets/snippets/helper.py
index 8d84221..2fa3b3f 100644
--- a/plugins/snippets/snippets/helper.py
+++ b/plugins/snippets/snippets/helper.py
@@ -15,191 +15,190 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-import string
from xml.sax import saxutils
-from xml.etree.ElementTree import *
+import xml.etree.ElementTree as et
import re
import codecs
-from gi.repository import Gtk, Gdk
+from gi.repository import Gtk
def message_dialog(par, typ, msg):
- d = Gtk.MessageDialog(par, Gtk.DialogFlags.MODAL, typ, Gtk.ButtonsType.OK, msg)
- d.set_property('use-markup', True)
+ d = Gtk.MessageDialog(par, Gtk.DialogFlags.MODAL, typ, Gtk.ButtonsType.OK, msg)
+ d.set_property('use-markup', True)
- d.run()
- d.destroy()
+ d.run()
+ d.destroy()
def compute_indentation(view, piter):
- line = piter.get_line()
- start = view.get_buffer().get_iter_at_line(line)
- end = start.copy()
+ line = piter.get_line()
+ start = view.get_buffer().get_iter_at_line(line)
+ end = start.copy()
- ch = end.get_char()
+ ch = end.get_char()
- while (ch.isspace() and ch != '\r' and ch != '\n' and \
- end.compare(piter) < 0):
- if not end.forward_char():
- break;
+ while (ch.isspace() and ch != '\r' and ch != '\n' and \
+ end.compare(piter) < 0):
+ if not end.forward_char():
+ break;
- ch = end.get_char()
+ ch = end.get_char()
- if start.equal(end):
- return ''
+ if start.equal(end):
+ return ''
- return start.get_slice(end)
+ return start.get_slice(end)
def markup_escape(text):
- return saxutils.escape(text)
+ return saxutils.escape(text)
def spaces_instead_of_tabs(view, text):
- if not view.get_insert_spaces_instead_of_tabs():
- return text
+ if not view.get_insert_spaces_instead_of_tabs():
+ return text
- return text.replace("\t", view.get_tab_width() * ' ')
+ return text.replace("\t", view.get_tab_width() * ' ')
def insert_with_indent(view, piter, text, indentfirst = True, context = None):
- text = spaces_instead_of_tabs(view, text)
- lines = text.split('\n')
- buf = view.get_buffer()
+ text = spaces_instead_of_tabs(view, text)
+ lines = text.split('\n')
+ buf = view.get_buffer()
- buf._snippets_context = context
+ buf._snippets_context = context
- if len(lines) == 1:
- view.get_buffer().insert(piter, text)
- else:
- # Compute indentation
- indent = compute_indentation(view, piter)
- text = ''
+ if len(lines) == 1:
+ view.get_buffer().insert(piter, text)
+ else:
+ # Compute indentation
+ indent = compute_indentation(view, piter)
+ text = ''
- for i in range(0, len(lines)):
- if indentfirst or i > 0:
- text += indent + lines[i] + '\n'
- else:
- text += lines[i] + '\n'
+ for i in range(0, len(lines)):
+ if indentfirst or i > 0:
+ text += indent + lines[i] + '\n'
+ else:
+ text += lines[i] + '\n'
- buf.insert(piter, text[:-1])
+ buf.insert(piter, text[:-1])
- buf._snippets_context = None
+ buf._snippets_context = None
def get_buffer_context(buf):
- if hasattr(buf, "_snippets_context"):
- return buf._snippets_context
- return None
+ if hasattr(buf, "_snippets_context"):
+ return buf._snippets_context
+ return None
def snippets_debug(*s):
- return
+ return
def write_xml(node, f, cdata_nodes=()):
- assert node is not None
+ assert node is not None
- if not hasattr(f, "write"):
- f = codecs.open(f, "wb", encoding="utf-8")
+ if not hasattr(f, "write"):
+ f = codecs.open(f, "wb", encoding="utf-8")
- # Encoding
- f.write("<?xml version='1.0' encoding='utf-8'?>\n")
+ # Encoding
+ f.write("<?xml version='1.0' encoding='utf-8'?>\n")
- _write_node(node, f, cdata_nodes)
+ _write_node(node, f, cdata_nodes)
def _write_indent(file, text, indent):
- file.write(' ' * indent + text)
+ file.write(' ' * indent + text)
def _write_node(node, file, cdata_nodes=(), indent=0):
- # write XML to file
- tag = node.tag
-
- if node is Comment:
- _write_indent(file, "<!-- %s -->\n" % saxutils.escape(node.text), indent)
- elif node is ProcessingInstruction:
- _write_indent(file, "<?%s?>\n" % saxutils.escape(node.text), indent)
- else:
- items = node.items()
-
- if items or node.text or len(node):
- _write_indent(file, "<" + tag, indent)
-
- if items:
- items.sort() # lexical order
- for k, v in items:
- file.write(" %s=%s" % (k, saxutils.quoteattr(v)))
- if node.text or len(node):
- file.write(">")
- if node.text and node.text.strip() != "":
- if tag in cdata_nodes:
- file.write(_cdata(node.text))
- else:
- file.write(saxutils.escape(node.text))
- else:
- file.write("\n")
-
- for n in node:
- _write_node(n, file, cdata_nodes, indent + 1)
-
- if not len(node):
- file.write("</" + tag + ">\n")
- else:
- _write_indent(file, "</" + tag + ">\n", \
- indent)
- else:
- file.write(" />\n")
-
- if node.tail and node.tail.strip() != "":
- file.write(saxutils.escape(node.tail))
+ # write XML to file
+ tag = node.tag
+
+ if node is et.Comment:
+ _write_indent(file, "<!-- %s -->\n" % saxutils.escape(node.text), indent)
+ elif node is et.ProcessingInstruction:
+ _write_indent(file, "<?%s?>\n" % saxutils.escape(node.text), indent)
+ else:
+ items = node.items()
+
+ if items or node.text or len(node):
+ _write_indent(file, "<" + tag, indent)
+
+ if items:
+ items.sort() # lexical order
+ for k, v in items:
+ file.write(" %s=%s" % (k, saxutils.quoteattr(v)))
+ if node.text or len(node):
+ file.write(">")
+ if node.text and node.text.strip() != "":
+ if tag in cdata_nodes:
+ file.write(_cdata(node.text))
+ else:
+ file.write(saxutils.escape(node.text))
+ else:
+ file.write("\n")
+
+ for n in node:
+ _write_node(n, file, cdata_nodes, indent + 1)
+
+ if not len(node):
+ file.write("</" + tag + ">\n")
+ else:
+ _write_indent(file, "</" + tag + ">\n", \
+ indent)
+ else:
+ file.write(" />\n")
+
+ if node.tail and node.tail.strip() != "":
+ file.write(saxutils.escape(node.tail))
def _cdata(text):
- return '<![CDATA[' + text.replace(']]>', ']]]]><![CDATA[>') + ']]>'
+ return '<![CDATA[' + text.replace(']]>', ']]]]><![CDATA[>') + ']]>'
def is_tab_trigger(w):
- if len(w) == 1 and not (w.isalnum() or w.isspace()):
- return True
+ if len(w) == 1 and not (w.isalnum() or w.isspace()):
+ return True
- if not is_first_tab_trigger_character(w[0]):
- return False
+ if not is_first_tab_trigger_character(w[0]):
+ return False
- for c in w:
- if not is_tab_trigger_character(c):
- return False
+ for c in w:
+ if not is_tab_trigger_character(c):
+ return False
- return True
+ return True
def is_first_tab_trigger_character(c):
- return c.isalpha() or c in '_:.'
+ return c.isalpha() or c in '_:.'
def is_tab_trigger_character(c):
- return c.isalnum() or c in '_:.'
+ return c.isalnum() or c in '_:.'
def buffer_word_boundary(buf):
- iter = buf.get_iter_at_mark(buf.get_insert())
- start = iter.copy()
+ iter = buf.get_iter_at_mark(buf.get_insert())
+ start = iter.copy()
- if not iter.starts_word() and (iter.inside_word() or iter.ends_word()):
- start.backward_word_start()
+ if not iter.starts_word() and (iter.inside_word() or iter.ends_word()):
+ start.backward_word_start()
- if not iter.ends_word() and iter.inside_word():
- iter.forward_word_end()
+ if not iter.ends_word() and iter.inside_word():
+ iter.forward_word_end()
- return (start, iter)
+ return (start, iter)
def buffer_line_boundary(buf):
- iter = buf.get_iter_at_mark(buf.get_insert())
- start = iter.copy()
- start.set_line_offset(0)
+ iter = buf.get_iter_at_mark(buf.get_insert())
+ start = iter.copy()
+ start.set_line_offset(0)
- if not iter.ends_line():
- iter.forward_to_line_end()
+ if not iter.ends_line():
+ iter.forward_to_line_end()
- return (start, iter)
+ return (start, iter)
def drop_get_uris(selection):
- uris = []
- if selection.targets_include_uri():
- data = selection.get_data()
- lines = re.split('\\s*[\\n\\r]+\\s*', data.strip())
+ uris = []
+ if selection.targets_include_uri():
+ data = selection.get_data()
+ lines = re.split('\\s*[\\n\\r]+\\s*', data.strip())
- for line in lines:
- if not line.startswith('#'):
- uris.append(line)
+ for line in lines:
+ if not line.startswith('#'):
+ uris.append(line)
- return uris
+ return uris
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/importer.py b/plugins/snippets/snippets/importer.py
index 14206f7..6e22dbe 100644
--- a/plugins/snippets/snippets/importer.py
+++ b/plugins/snippets/snippets/importer.py
@@ -21,106 +21,106 @@ import tempfile
import sys
import shutil
-from .library import *
+from .library import Library
class Importer:
- def __init__(self, filename):
- self.filename = filename
+ def __init__(self, filename):
+ self.filename = filename
- def import_destination(self, filename):
- userdir = Library().userdir
+ def import_destination(self, filename):
+ userdir = Library().userdir
- filename = os.path.basename(filename)
- (root, ext) = os.path.splitext(filename)
+ filename = os.path.basename(filename)
+ (root, ext) = os.path.splitext(filename)
- filename = os.path.join(userdir, root + ext)
- i = 1
+ filename = os.path.join(userdir, root + ext)
+ i = 1
- while os.path.exists(filename):
- filename = os.path.join(userdir, root + '_' + str(i) + ext)
- i += 1
+ while os.path.exists(filename):
+ filename = os.path.join(userdir, root + '_' + str(i) + ext)
+ i += 1
- return (userdir, filename)
+ return (userdir, filename)
- def import_file(self, filename):
- if not os.path.exists(filename):
- return _('File "%s" does not exist') % filename
+ def import_file(self, filename):
+ if not os.path.exists(filename):
+ return _('File "%s" does not exist') % filename
- if not os.path.isfile(filename):
- return _('File "%s" is not a valid snippets file') % filename
+ if not os.path.isfile(filename):
+ return _('File "%s" is not a valid snippets file') % filename
- # Find destination for file to copy to
- destdir, dest = self.import_destination(filename)
+ # Find destination for file to copy to
+ destdir, dest = self.import_destination(filename)
- # Make sure dir exists
- try:
- os.makedirs(destdir)
- except OSError as e:
- if e.errno != errno.EEXIST:
- raise
+ # Make sure dir exists
+ try:
+ os.makedirs(destdir)
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ raise
- # Copy file
- shutil.copy(filename, dest)
+ # Copy file
+ shutil.copy(filename, dest)
- # Add library
- if not Library().add_user_library(dest):
- return _('Imported file "%s" is not a valid snippets file') % os.path.basename(dest)
+ # Add library
+ if not Library().add_user_library(dest):
+ return _('Imported file "%s" is not a valid snippets file') % os.path.basename(dest)
- def import_xml(self):
- return self.import_file(self.filename)
+ def import_xml(self):
+ return self.import_file(self.filename)
- def import_archive(self, cmd):
- dirname = tempfile.mkdtemp()
- status = os.system('cd %s; %s "%s"' % (dirname, cmd, self.filename))
+ def import_archive(self, cmd):
+ dirname = tempfile.mkdtemp()
+ status = os.system('cd %s; %s "%s"' % (dirname, cmd, self.filename))
- if status != 0:
- return _('The archive "%s" could not be extracted' % self.filename)
+ if status != 0:
+ return _('The archive "%s" could not be extracted' % self.filename)
- errors = []
+ errors = []
- # Now import all the files from the archive
- for f in os.listdir(dirname):
- f = os.path.join(dirname, f)
+ # Now import all the files from the archive
+ for f in os.listdir(dirname):
+ f = os.path.join(dirname, f)
- if os.path.isfile(f):
- if self.import_file(f):
- errors.append(os.path.basename(f))
- else:
- sys.stderr.write('Skipping %s, not a valid snippets file' %
os.path.basename(f))
+ if os.path.isfile(f):
+ if self.import_file(f):
+ errors.append(os.path.basename(f))
+ else:
+ sys.stderr.write('Skipping %s, not a valid snippets file' % os.path.basename(f))
- # Remove the temporary directory
- shutil.rmtree(dirname)
+ # Remove the temporary directory
+ shutil.rmtree(dirname)
- if len(errors) > 0:
- return _('The following files could not be imported: %s') % ', '.join(errors)
+ if len(errors) > 0:
+ return _('The following files could not be imported: %s') % ', '.join(errors)
- def import_targz(self):
- self.import_archive('tar -x --gzip -f')
+ def import_targz(self):
+ self.import_archive('tar -x --gzip -f')
- def import_tarbz2(self):
- self.import_archive('tar -x --bzip2 -f')
+ def import_tarbz2(self):
+ self.import_archive('tar -x --bzip2 -f')
- def import_tar(self):
- self.import_archive('tar -xf')
+ def import_tar(self):
+ self.import_archive('tar -xf')
- def run(self):
- if not os.path.exists(self.filename):
- return _('File "%s" does not exist') % self.filename
+ def run(self):
+ if not os.path.exists(self.filename):
+ return _('File "%s" does not exist') % self.filename
- if not os.path.isfile(self.filename):
- return _('File "%s" is not a valid snippets archive') % self.filename
+ if not os.path.isfile(self.filename):
+ return _('File "%s" is not a valid snippets archive') % self.filename
- (root, ext) = os.path.splitext(self.filename)
+ (root, ext) = os.path.splitext(self.filename)
- actions = {'.tar.gz': self.import_targz,
- '.tar.bz2': self.import_tarbz2,
- '.xml': self.import_xml,
- '.tar': self.import_tar}
+ actions = {'.tar.gz': self.import_targz,
+ '.tar.bz2': self.import_tarbz2,
+ '.xml': self.import_xml,
+ '.tar': self.import_tar}
- for k, v in actions.items():
- if self.filename.endswith(k):
- return v()
+ for k, v in actions.items():
+ if self.filename.endswith(k):
+ return v()
- return _('File "%s" is not a valid snippets archive') % self.filename
+ return _('File "%s" is not a valid snippets archive') % self.filename
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/languagemanager.py b/plugins/snippets/snippets/languagemanager.py
index 30b079e..6f74319 100644
--- a/plugins/snippets/snippets/languagemanager.py
+++ b/plugins/snippets/snippets/languagemanager.py
@@ -24,17 +24,17 @@ global manager
manager = None
def get_language_manager():
- global manager
+ global manager
- if not manager:
- dirs = []
+ if not manager:
+ dirs = []
- for d in Library().systemdirs:
- dirs.append(os.path.join(d, 'lang'))
+ for d in Library().systemdirs:
+ dirs.append(os.path.join(d, 'lang'))
- manager = GtkSource.LanguageManager()
- manager.set_search_path(dirs + manager.get_search_path())
+ manager = GtkSource.LanguageManager()
+ manager.set_search_path(dirs + manager.get_search_path())
- return manager
+ return manager
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/library.py b/plugins/snippets/snippets/library.py
index c60695f..92adc3c 100644
--- a/plugins/snippets/snippets/library.py
+++ b/plugins/snippets/snippets/library.py
@@ -18,977 +18,972 @@
import os
import weakref
import sys
-import tempfile
import re
from gi.repository import Gdk, Gtk
import xml.etree.ElementTree as et
-from .helper import *
+from . import helper
class NamespacedId:
- def __init__(self, namespace, id):
- if not id:
- self.id = None
- else:
- if namespace:
- self.id = namespace + '-'
- else:
- self.id = 'global-'
+ def __init__(self, namespace, id):
+ if not id:
+ self.id = None
+ else:
+ if namespace:
+ self.id = namespace + '-'
+ else:
+ self.id = 'global-'
- self.id += id
+ self.id += id
class SnippetData:
- PROPS = {'tag': '', 'text': '', 'description': 'New snippet',
- 'accelerator': '', 'drop-targets': ''}
-
- def __init__(self, node, library):
- self.priv_id = node.attrib.get('id')
+ PROPS = {'tag': '', 'text': '', 'description': 'New snippet',
+ 'accelerator': '', 'drop-targets': ''}
- self.set_library(library)
- self.valid = False
- self.set_node(node)
+ def __init__(self, node, library):
+ self.priv_id = node.attrib.get('id')
- def can_modify(self):
- return (self.library and (isinstance(self.library(), SnippetsUserFile)))
+ self.set_library(library)
+ self.valid = False
+ self.set_node(node)
- def set_library(self, library):
- if library:
- self.library = weakref.ref(library)
- else:
- self.library = None
+ def can_modify(self):
+ return (self.library and (isinstance(self.library(), SnippetsUserFile)))
- self.id = NamespacedId(self.language(), self.priv_id).id
+ def set_library(self, library):
+ if library:
+ self.library = weakref.ref(library)
+ else:
+ self.library = None
- def set_node(self, node):
- if self.can_modify():
- self.node = node
- else:
- self.node = None
+ self.id = NamespacedId(self.language(), self.priv_id).id
- self.init_snippet_data(node)
+ def set_node(self, node):
+ if self.can_modify():
+ self.node = node
+ else:
+ self.node = None
- def init_snippet_data(self, node):
- if node == None:
- return
+ self.init_snippet_data(node)
- self.override = node.attrib.get('override')
+ def init_snippet_data(self, node):
+ if node == None:
+ return
- self.properties = {}
- props = SnippetData.PROPS.copy()
+ self.override = node.attrib.get('override')
- # Store all properties present
- for child in node:
- if child.tag in props:
- del props[child.tag]
+ self.properties = {}
+ props = SnippetData.PROPS.copy()
- # Normalize accelerator
- if child.tag == 'accelerator' and child.text != None:
- keyval, mod = Gtk.accelerator_parse(child.text)
+ # Store all properties present
+ for child in node:
+ if child.tag in props:
+ del props[child.tag]
- if Gtk.accelerator_valid(keyval, mod):
- child.text = Gtk.accelerator_name(keyval, mod)
- else:
- child.text = ''
+ # Normalize accelerator
+ if child.tag == 'accelerator' and child.text != None:
+ keyval, mod = Gtk.accelerator_parse(child.text)
- if self.can_modify():
- self.properties[child.tag] = child
- else:
- self.properties[child.tag] = child.text or ''
+ if Gtk.accelerator_valid(keyval, mod):
+ child.text = Gtk.accelerator_name(keyval, mod)
+ else:
+ child.text = ''
- # Create all the props that were not found so we stay consistent
- for prop in props:
- if self.can_modify():
- child = et.SubElement(node, prop)
+ if self.can_modify():
+ self.properties[child.tag] = child
+ else:
+ self.properties[child.tag] = child.text or ''
- child.text = props[prop]
- self.properties[prop] = child
- else:
- self.properties[prop] = props[prop]
+ # Create all the props that were not found so we stay consistent
+ for prop in props:
+ if self.can_modify():
+ child = et.SubElement(node, prop)
- self.check_validation()
+ child.text = props[prop]
+ self.properties[prop] = child
+ else:
+ self.properties[prop] = props[prop]
+
+ self.check_validation()
- def check_validation(self):
- if not self['tag'] and not self['accelerator'] and not self['drop-targets']:
- return False
+ def check_validation(self):
+ if not self['tag'] and not self['accelerator'] and not self['drop-targets']:
+ return False
- library = Library()
- keyval, mod = Gtk.accelerator_parse(self['accelerator'])
+ library = Library()
+ keyval, mod = Gtk.accelerator_parse(self['accelerator'])
- self.valid = library.valid_tab_trigger(self['tag']) and \
- (not self['accelerator'] or library.valid_accelerator(keyval, mod))
+ self.valid = library.valid_tab_trigger(self['tag']) and \
+ (not self['accelerator'] or library.valid_accelerator(keyval, mod))
- def _format_prop(self, prop, value):
- if prop == 'drop-targets' and value != '':
- return re.split('\\s*[,;]\\s*', value)
- else:
- return value
+ def _format_prop(self, prop, value):
+ if prop == 'drop-targets' and value != '':
+ return re.split('\\s*[,;]\\s*', value)
+ else:
+ return value
- def __getitem__(self, prop):
- if prop in self.properties:
- if self.can_modify():
- return self._format_prop(prop, self.properties[prop].text or '')
- else:
- return self._format_prop(prop, self.properties[prop] or '')
+ def __getitem__(self, prop):
+ if prop in self.properties:
+ if self.can_modify():
+ return self._format_prop(prop, self.properties[prop].text or '')
+ else:
+ return self._format_prop(prop, self.properties[prop] or '')
- return self._format_prop(prop, '')
+ return self._format_prop(prop, '')
- def __setitem__(self, prop, value):
- if not prop in self.properties:
- return
+ def __setitem__(self, prop, value):
+ if not prop in self.properties:
+ return
- if isinstance(value, list):
- value = ','.join(value)
+ if isinstance(value, list):
+ value = ','.join(value)
- if not self.can_modify() and self.properties[prop] != value:
- # ohoh, this is not can_modify, but it needs to be changed...
- # make sure it is transfered to the changes file and set all the
- # fields.
- # This snippet data container will effectively become the container
- # for the newly created node, but transparently to whoever uses
- # it
- self._override()
+ if not self.can_modify() and self.properties[prop] != value:
+ # ohoh, this is not can_modify, but it needs to be changed...
+ # make sure it is transfered to the changes file and set all the
+ # fields.
+ # This snippet data container will effectively become the container
+ # for the newly created node, but transparently to whoever uses
+ # it
+ self._override()
- if self.can_modify() and self.properties[prop].text != value:
- if self.library():
- self.library().tainted = True
+ if self.can_modify() and self.properties[prop].text != value:
+ if self.library():
+ self.library().tainted = True
- oldvalue = self.properties[prop].text
- self.properties[prop].text = value
+ oldvalue = self.properties[prop].text
+ self.properties[prop].text = value
- if prop == 'tag' or prop == 'accelerator' or prop == 'drop-targets':
- container = Library().container(self.language())
- container.prop_changed(self, prop, oldvalue)
+ if prop == 'tag' or prop == 'accelerator' or prop == 'drop-targets':
+ container = Library().container(self.language())
+ container.prop_changed(self, prop, oldvalue)
- self.check_validation()
+ self.check_validation()
- def language(self):
- if self.library and self.library():
- return self.library().language
- else:
- return None
+ def language(self):
+ if self.library and self.library():
+ return self.library().language
+ else:
+ return None
- def is_override(self):
- return self.override and Library().overridden[self.override]
+ def is_override(self):
+ return self.override and Library().overridden[self.override]
- def to_xml(self):
- return self._create_xml()
+ def to_xml(self):
+ return self._create_xml()
- def _create_xml(self, parent=None, update=False, attrib={}):
- # Create a new node
- if parent != None:
- element = et.SubElement(parent, 'snippet', attrib)
- else:
- element = et.Element('snippet')
+ def _create_xml(self, parent=None, update=False, attrib={}):
+ # Create a new node
+ if parent != None:
+ element = et.SubElement(parent, 'snippet', attrib)
+ else:
+ element = et.Element('snippet')
- # Create all the properties
- for p in self.properties:
- prop = et.SubElement(element, p)
- prop.text = self[p]
+ # Create all the properties
+ for p in self.properties:
+ prop = et.SubElement(element, p)
+ prop.text = self[p]
- if update:
- self.properties[p] = prop
+ if update:
+ self.properties[p] = prop
- return element
+ return element
- def _override(self):
- # Find the user file
- target = Library().get_user_library(self.language())
+ def _override(self):
+ # Find the user file
+ target = Library().get_user_library(self.language())
- # Create a new node there with override
- element = self._create_xml(target.root, True, {'override': self.id})
+ # Create a new node there with override
+ element = self._create_xml(target.root, True, {'override': self.id})
- # Create an override snippet data, feed it element so that it stores
- # all the values and then set the node to None so that it only contains
- # the values in .properties
- override = SnippetData(element, self.library())
- override.set_node(None)
- override.id = self.id
+ # Create an override snippet data, feed it element so that it stores
+ # all the values and then set the node to None so that it only contains
+ # the values in .properties
+ override = SnippetData(element, self.library())
+ override.set_node(None)
+ override.id = self.id
- # Set our node to the new element
- self.node = element
+ # Set our node to the new element
+ self.node = element
- # Set the override to our id
- self.override = self.id
- self.id = None
+ # Set the override to our id
+ self.override = self.id
+ self.id = None
- # Set the new library
- self.set_library(target)
+ # Set the new library
+ self.set_library(target)
- # The library is tainted because we added this snippet
- target.tainted = True
+ # The library is tainted because we added this snippet
+ target.tainted = True
- # Add the override
- Library().overridden[self.override] = override
+ # Add the override
+ Library().overridden[self.override] = override
- def revert(self, snippet):
- userlib = self.library()
- self.set_library(snippet.library())
+ def revert(self, snippet):
+ userlib = self.library()
+ self.set_library(snippet.library())
- userlib.remove(self.node)
+ userlib.remove(self.node)
- self.set_node(None)
+ self.set_node(None)
- # Copy the properties
- self.properties = snippet.properties
+ # Copy the properties
+ self.properties = snippet.properties
- # Set the id
- self.id = snippet.id
+ # Set the id
+ self.id = snippet.id
- # Reset the override flag
- self.override = None
+ # Reset the override flag
+ self.override = None
class SnippetsTreeBuilder(et.TreeBuilder):
- def __init__(self, start=None, end=None):
- et.TreeBuilder.__init__(self)
- self.set_start(start)
- self.set_end(end)
+ def __init__(self, start=None, end=None):
+ et.TreeBuilder.__init__(self)
+ self.set_start(start)
+ self.set_end(end)
- def set_start(self, start):
- self._start_cb = start
+ def set_start(self, start):
+ self._start_cb = start
- def set_end(self, end):
- self._end_cb = end
+ def set_end(self, end):
+ self._end_cb = end
- def start(self, tag, attrs):
- result = et.TreeBuilder.start(self, tag, attrs)
+ def start(self, tag, attrs):
+ result = et.TreeBuilder.start(self, tag, attrs)
- if self._start_cb:
- self._start_cb(result)
+ if self._start_cb:
+ self._start_cb(result)
- return result
+ return result
- def end(self, tag):
- result = et.TreeBuilder.end(self, tag)
+ def end(self, tag):
+ result = et.TreeBuilder.end(self, tag)
- if self._end_cb:
- self._end_cb(result)
+ if self._end_cb:
+ self._end_cb(result)
- return result
+ return result
class LanguageContainer:
- def __init__(self, language):
- self.language = language
- self.snippets = []
- self.snippets_by_prop = {'tag': {}, 'accelerator': {}, 'drop-targets': {}}
- self.accel_group = Gtk.AccelGroup()
- self._refs = 0
+ def __init__(self, language):
+ self.language = language
+ self.snippets = []
+ self.snippets_by_prop = {'tag': {}, 'accelerator': {}, 'drop-targets': {}}
+ self.accel_group = Gtk.AccelGroup()
+ self._refs = 0
- def _add_prop(self, snippet, prop, value=0):
- if value == 0:
- value = snippet[prop]
+ def _add_prop(self, snippet, prop, value=0):
+ if value == 0:
+ value = snippet[prop]
- if not value or value == '':
- return
+ if not value or value == '':
+ return
- snippets_debug('Added ', prop ,' ', value, ' to ', str(self.language))
+ helper.snippets_debug('Added ', prop ,' ', value, ' to ', str(self.language))
- if prop == 'accelerator':
- keyval, mod = Gtk.accelerator_parse(value)
- self.accel_group.connect(keyval, mod, 0, \
- Library().accelerator_activated)
+ if prop == 'accelerator':
+ keyval, mod = Gtk.accelerator_parse(value)
+ self.accel_group.connect(keyval, mod, 0, \
+ Library().accelerator_activated)
- snippets = self.snippets_by_prop[prop]
+ snippets = self.snippets_by_prop[prop]
- if not isinstance(value, list):
- value = [value]
+ if not isinstance(value, list):
+ value = [value]
- for val in value:
- if val in snippets:
- snippets[val].append(snippet)
- else:
- snippets[val] = [snippet]
+ for val in value:
+ if val in snippets:
+ snippets[val].append(snippet)
+ else:
+ snippets[val] = [snippet]
- def _remove_prop(self, snippet, prop, value=0):
- if value == 0:
- value = snippet[prop]
+ def _remove_prop(self, snippet, prop, value=0):
+ if value == 0:
+ value = snippet[prop]
- if not value or value == '':
- return
+ if not value or value == '':
+ return
- snippets_debug('Removed ', prop, ' ', value, ' from ', str(self.language))
+ helper.snippets_debug('Removed ', prop, ' ', value, ' from ', str(self.language))
- if prop == 'accelerator':
- keyval, mod = Gtk.accelerator_parse(value)
- self.accel_group.disconnect_key(keyval, mod)
+ if prop == 'accelerator':
+ keyval, mod = Gtk.accelerator_parse(value)
+ self.accel_group.disconnect_key(keyval, mod)
- snippets = self.snippets_by_prop[prop]
+ snippets = self.snippets_by_prop[prop]
- if not isinstance(value, list):
- value = [value]
+ if not isinstance(value, list):
+ value = [value]
- for val in value:
- try:
- snippets[val].remove(snippet)
- except:
- True
+ for val in value:
+ try:
+ snippets[val].remove(snippet)
+ except:
+ True
- def append(self, snippet):
- tag = snippet['tag']
- accelerator = snippet['accelerator']
+ def append(self, snippet):
+ self.snippets.append(snippet)
- self.snippets.append(snippet)
+ self._add_prop(snippet, 'tag')
+ self._add_prop(snippet, 'accelerator')
+ self._add_prop(snippet, 'drop-targets')
- self._add_prop(snippet, 'tag')
- self._add_prop(snippet, 'accelerator')
- self._add_prop(snippet, 'drop-targets')
+ return snippet
- return snippet
+ def remove(self, snippet):
+ try:
+ self.snippets.remove(snippet)
+ except:
+ True
- def remove(self, snippet):
- try:
- self.snippets.remove(snippet)
- except:
- True
+ self._remove_prop(snippet, 'tag')
+ self._remove_prop(snippet, 'accelerator')
+ self._remove_prop(snippet, 'drop-targets')
- self._remove_prop(snippet, 'tag')
- self._remove_prop(snippet, 'accelerator')
- self._remove_prop(snippet, 'drop-targets')
+ def prop_changed(self, snippet, prop, oldvalue):
+ helper.snippets_debug('PROP CHANGED (', prop, ')', oldvalue)
- def prop_changed(self, snippet, prop, oldvalue):
- snippets_debug('PROP CHANGED (', prop, ')', oldvalue)
+ self._remove_prop(snippet, prop, oldvalue)
+ self._add_prop(snippet, prop)
- self._remove_prop(snippet, prop, oldvalue)
- self._add_prop(snippet, prop)
+ def from_prop(self, prop, value):
+ snippets = self.snippets_by_prop[prop]
- def from_prop(self, prop, value):
- snippets = self.snippets_by_prop[prop]
+ if prop == 'drop-targets':
+ s = []
- if prop == 'drop-targets':
- s = []
+ # FIXME: change this to use
+ # gnomevfs.mime_type_get_equivalence when it comes
+ # available
+ for key, val in snippets.items():
+ if not value.startswith(key):
+ continue
- # FIXME: change this to use
- # gnomevfs.mime_type_get_equivalence when it comes
- # available
- for key, val in snippets.items():
- if not value.startswith(key):
- continue
+ for snippet in snippets[key]:
+ if not snippet in s:
+ s.append(snippet)
- for snippet in snippets[key]:
- if not snippet in s:
- s.append(snippet)
+ return s
+ else:
+ if value in snippets:
+ return snippets[value]
+ else:
+ return []
- return s
- else:
- if value in snippets:
- return snippets[value]
- else:
- return []
-
- def ref(self):
- self._refs += 1
+ def ref(self):
+ self._refs += 1
- return True
+ return True
- def unref(self):
- if self._refs > 0:
- self._refs -= 1
+ def unref(self):
+ if self._refs > 0:
+ self._refs -= 1
- return self._refs != 0
+ return self._refs != 0
class SnippetsSystemFile:
- def __init__(self, path=None):
- self.path = path
- self.loaded = False
- self.language = None
- self.ok = True
- self.need_id = True
-
- def load_error(self, message):
- sys.stderr.write("An error occurred loading " + self.path + ":\n")
- sys.stderr.write(message + "\nSnippets in this file will not be " \
- "available, please correct or remove the file.\n")
-
- def _add_snippet(self, element):
- if not self.need_id or element.attrib.get('id'):
- self.loading_elements.append(element)
-
- def set_language(self, element):
- self.language = element.attrib.get('language')
-
- if self.language:
- self.language = self.language.lower()
-
- def _set_root(self, element):
- self.set_language(element)
-
- def _preprocess_element(self, element):
- if not self.loaded:
- if not element.tag == "snippets":
- self.load_error("Root element should be `snippets' instead " \
- "of `%s'" % element.tag)
- return False
- else:
- self._set_root(element)
- self.loaded = True
- elif element.tag != 'snippet' and not self.insnippet:
- self.load_error("Element should be `snippet' instead of `%s'" \
- % element.tag)
- return False
- else:
- self.insnippet = True
-
- return True
-
- def _process_element(self, element):
- if element.tag == 'snippet':
- self._add_snippet(element)
- self.insnippet = False
-
- return True
-
- def ensure(self):
- if not self.ok or self.loaded:
- return
-
- self.load()
-
- def parse_xml(self, readsize=16384):
- if not self.path:
- return
+ def __init__(self, path=None):
+ self.path = path
+ self.loaded = False
+ self.language = None
+ self.ok = True
+ self.need_id = True
+
+ def load_error(self, message):
+ sys.stderr.write("An error occurred loading " + self.path + ":\n")
+ sys.stderr.write(message + "\nSnippets in this file will not be " \
+ "available, please correct or remove the file.\n")
+
+ def _add_snippet(self, element):
+ if not self.need_id or element.attrib.get('id'):
+ self.loading_elements.append(element)
+
+ def set_language(self, element):
+ self.language = element.attrib.get('language')
+
+ if self.language:
+ self.language = self.language.lower()
+
+ def _set_root(self, element):
+ self.set_language(element)
+
+ def _preprocess_element(self, element):
+ if not self.loaded:
+ if not element.tag == "snippets":
+ self.load_error("Root element should be `snippets' instead " \
+ "of `%s'" % element.tag)
+ return False
+ else:
+ self._set_root(element)
+ self.loaded = True
+ elif element.tag != 'snippet' and not self.insnippet:
+ self.load_error("Element should be `snippet' instead of `%s'" \
+ % element.tag)
+ return False
+ else:
+ self.insnippet = True
- elements = []
+ return True
- builder = SnippetsTreeBuilder( \
- lambda node: elements.append((node, True)), \
- lambda node: elements.append((node, False)))
+ def _process_element(self, element):
+ if element.tag == 'snippet':
+ self._add_snippet(element)
+ self.insnippet = False
- parser = et.XMLParser(target=builder)
- self.insnippet = False
+ return True
- try:
- f = open(self.path, "r")
- except IOError:
- self.ok = False
- return
+ def ensure(self):
+ if not self.ok or self.loaded:
+ return
- while True:
- try:
- data = f.read(readsize)
- except IOError:
- self.ok = False
- break
+ self.load()
- if not data:
- break
+ def parse_xml(self, readsize=16384):
+ if not self.path:
+ return
- try:
- parser.feed(data)
- except Exception:
- self.ok = False
- break
+ elements = []
- for element in elements:
- yield element
+ builder = SnippetsTreeBuilder( \
+ lambda node: elements.append((node, True)), \
+ lambda node: elements.append((node, False)))
- del elements[:]
+ parser = et.XMLParser(target=builder)
+ self.insnippet = False
- f.close()
+ try:
+ f = open(self.path, "r")
+ except IOError:
+ self.ok = False
+ return
- def load(self):
- if not self.ok:
- return
+ while True:
+ try:
+ data = f.read(readsize)
+ except IOError:
+ self.ok = False
+ break
- snippets_debug("Loading library (" + str(self.language) + "): " + \
- self.path)
+ if not data:
+ break
- self.loaded = False
+ try:
+ parser.feed(data)
+ except Exception:
self.ok = False
- self.loading_elements = []
-
- for element in self.parse_xml():
- if element[1]:
- if not self._preprocess_element(element[0]):
- del self.loading_elements[:]
- return
- else:
- if not self._process_element(element[0]):
- del self.loading_elements[:]
- return
-
- for element in self.loading_elements:
- snippet = Library().add_snippet(self, element)
-
- del self.loading_elements[:]
- self.ok = True
-
- # This function will get the language for a file by just inspecting the
- # root element of the file. This is provided so that a cache can be built
- # for which file contains which language.
- # It returns the name of the language
- def ensure_language(self):
- if not self.loaded:
- self.ok = False
-
- for element in self.parse_xml(256):
- if element[1]:
- if element[0].tag == 'snippets':
- self.set_language(element[0])
- self.ok = True
-
- break
-
- def unload(self):
- snippets_debug("Unloading library (" + str(self.language) + "): " + \
- self.path)
- self.language = None
- self.loaded = False
- self.ok = True
+ break
-class SnippetsUserFile(SnippetsSystemFile):
- def __init__(self, path=None):
- SnippetsSystemFile.__init__(self, path)
- self.tainted = False
- self.need_id = False
+ for element in elements:
+ yield element
- def _set_root(self, element):
- SnippetsSystemFile._set_root(self, element)
- self.root = element
+ del elements[:]
- def add_prop(self, node, tag, data):
- if data[tag]:
- prop = et.SubElement(node, tag)
- prop.text = data[tag]
+ f.close()
- return prop
- else:
- return None
+ def load(self):
+ if not self.ok:
+ return
- def new_snippet(self, properties=None):
- if (not self.ok) or self.root == None:
- return None
+ helper.snippets_debug("Loading library (" + str(self.language) + "): " + \
+ self.path)
- element = et.SubElement(self.root, 'snippet')
+ self.loaded = False
+ self.ok = False
+ self.loading_elements = []
- if properties:
- for prop in properties:
- sub = et.SubElement(element, prop)
- sub.text = properties[prop]
+ for element in self.parse_xml():
+ if element[1]:
+ if not self._preprocess_element(element[0]):
+ del self.loading_elements[:]
+ return
+ else:
+ if not self._process_element(element[0]):
+ del self.loading_elements[:]
+ return
- self.tainted = True
+ for element in self.loading_elements:
+ Library().add_snippet(self, element)
- return Library().add_snippet(self, element)
+ del self.loading_elements[:]
+ self.ok = True
- def set_language(self, element):
- SnippetsSystemFile.set_language(self, element)
+ # This function will get the language for a file by just inspecting the
+ # root element of the file. This is provided so that a cache can be built
+ # for which file contains which language.
+ # It returns the name of the language
+ def ensure_language(self):
+ if not self.loaded:
+ self.ok = False
- filename = os.path.basename(self.path).lower()
+ for element in self.parse_xml(256):
+ if element[1]:
+ if element[0].tag == 'snippets':
+ self.set_language(element[0])
+ self.ok = True
- if not self.language and filename == "global.xml":
- self.modifier = True
- elif self.language and filename == self.language + ".xml":
- self.modifier = True
- else:
- self.modifier = False
+ break
- def create_root(self, language):
- if self.loaded:
- snippets_debug('Not creating root, already loaded')
- return
+ def unload(self):
+ helper.snippets_debug("Unloading library (" + str(self.language) + "): " + \
+ self.path)
+ self.language = None
+ self.loaded = False
+ self.ok = True
- if language:
- root = et.Element('snippets', {'language': language})
- self.path = os.path.join(Library().userdir, language.lower() + '.xml')
- else:
- root = et.Element('snippets')
- self.path = os.path.join(Library().userdir, 'global.xml')
-
- self._set_root(root)
- self.loaded = True
- self.ok = True
- self.tainted = True
- self.save()
-
- def remove(self, element):
- try:
- self.root.remove(element)
- self.tainted = True
- except:
- return
-
- try:
- first = self.root[0]
- except:
- # No more elements, this library is useless now
- Library().remove_library(self)
-
- def save(self):
- if not self.ok or self.root == None or not self.tainted:
- return
-
- path = os.path.dirname(self.path)
-
- try:
- if not os.path.isdir(path):
- os.makedirs(path, 0o755)
- except OSError:
- # TODO: this is bad...
- sys.stderr.write("Error in making dirs\n")
-
- try:
- write_xml(self.root, self.path, ('text', 'accelerator'))
- self.tainted = False
- except IOError:
- # Couldn't save, what to do
- sys.stderr.write("Could not save user snippets file to " + \
- self.path + "\n")
-
- def unload(self):
- SnippetsSystemFile.unload(self)
- self.root = None
+class SnippetsUserFile(SnippetsSystemFile):
+ def __init__(self, path=None):
+ SnippetsSystemFile.__init__(self, path)
+ self.tainted = False
+ self.need_id = False
+
+ def _set_root(self, element):
+ SnippetsSystemFile._set_root(self, element)
+ self.root = element
+
+ def add_prop(self, node, tag, data):
+ if data[tag]:
+ prop = et.SubElement(node, tag)
+ prop.text = data[tag]
+
+ return prop
+ else:
+ return None
+
+ def new_snippet(self, properties=None):
+ if (not self.ok) or self.root == None:
+ return None
+
+ element = et.SubElement(self.root, 'snippet')
+
+ if properties:
+ for prop in properties:
+ sub = et.SubElement(element, prop)
+ sub.text = properties[prop]
+
+ self.tainted = True
+
+ return Library().add_snippet(self, element)
+
+ def set_language(self, element):
+ SnippetsSystemFile.set_language(self, element)
+
+ filename = os.path.basename(self.path).lower()
+
+ if not self.language and filename == "global.xml":
+ self.modifier = True
+ elif self.language and filename == self.language + ".xml":
+ self.modifier = True
+ else:
+ self.modifier = False
+
+ def create_root(self, language):
+ if self.loaded:
+ helper.snippets_debug('Not creating root, already loaded')
+ return
+
+ if language:
+ root = et.Element('snippets', {'language': language})
+ self.path = os.path.join(Library().userdir, language.lower() + '.xml')
+ else:
+ root = et.Element('snippets')
+ self.path = os.path.join(Library().userdir, 'global.xml')
+
+ self._set_root(root)
+ self.loaded = True
+ self.ok = True
+ self.tainted = True
+ self.save()
+
+ def remove(self, element):
+ try:
+ self.root.remove(element)
+ self.tainted = True
+ except:
+ return
+
+ try:
+ self.root[0]
+ except:
+ # No more elements, this library is useless now
+ Library().remove_library(self)
+
+ def save(self):
+ if not self.ok or self.root == None or not self.tainted:
+ return
+
+ path = os.path.dirname(self.path)
+
+ try:
+ if not os.path.isdir(path):
+ os.makedirs(path, 0o755)
+ except OSError:
+ # TODO: this is bad...
+ sys.stderr.write("Error in making dirs\n")
+
+ try:
+ helper.write_xml(self.root, self.path, ('text', 'accelerator'))
+ self.tainted = False
+ except IOError:
+ # Couldn't save, what to do
+ sys.stderr.write("Could not save user snippets file to " + \
+ self.path + "\n")
+
+ def unload(self):
+ SnippetsSystemFile.unload(self)
+ self.root = None
class Singleton(object):
- _instance = None
+ _instance = None
- def __new__(cls, *args, **kwargs):
- if not cls._instance:
- cls._instance = super(Singleton, cls).__new__(
- cls, *args, **kwargs)
- cls._instance.__init_once__()
+ def __new__(cls, *args, **kwargs):
+ if not cls._instance:
+ cls._instance = super(Singleton, cls).__new__(
+ cls, *args, **kwargs)
+ cls._instance.__init_once__()
- return cls._instance
+ return cls._instance
class Library(Singleton):
- def __init_once__(self):
- self._accelerator_activated_cb = []
- self.loaded = False
- self.check_buffer = Gtk.TextBuffer()
+ def __init_once__(self):
+ self._accelerator_activated_cb = []
+ self.loaded = False
+ self.check_buffer = Gtk.TextBuffer()
- def set_dirs(self, userdir, systemdirs):
- self.userdir = userdir
- self.systemdirs = systemdirs
+ def set_dirs(self, userdir, systemdirs):
+ self.userdir = userdir
+ self.systemdirs = systemdirs
- self.libraries = {}
- self.containers = {}
- self.overridden = {}
- self.loaded_ids = []
+ self.libraries = {}
+ self.containers = {}
+ self.overridden = {}
+ self.loaded_ids = []
- self.loaded = False
+ self.loaded = False
- def add_accelerator_callback(self, cb):
- self._accelerator_activated_cb.append(cb)
+ def add_accelerator_callback(self, cb):
+ self._accelerator_activated_cb.append(cb)
- def remove_accelerator_callback(self, cb):
- self._accelerator_activated_cb.remove(cb)
+ def remove_accelerator_callback(self, cb):
+ self._accelerator_activated_cb.remove(cb)
- def accelerator_activated(self, group, obj, keyval, mod):
- ret = False
+ def accelerator_activated(self, group, obj, keyval, mod):
+ ret = False
- for cb in self._accelerator_activated_cb:
- ret = cb(group, obj, keyval, mod)
+ for cb in self._accelerator_activated_cb:
+ ret = cb(group, obj, keyval, mod)
- if ret:
- break
+ if ret:
+ break
- return ret
+ return ret
- def add_snippet(self, library, element):
- container = self.container(library.language)
- overrided = self.overrided(library, element)
+ def add_snippet(self, library, element):
+ container = self.container(library.language)
+ overrided = self.overrided(library, element)
- if overrided:
- overrided.set_library(library)
- snippets_debug('Snippet is overriden: ' + overrided['description'])
- return None
+ if overrided:
+ overrided.set_library(library)
+ helper.snippets_debug('Snippet is overriden: ' + overrided['description'])
+ return None
- snippet = SnippetData(element, library)
+ snippet = SnippetData(element, library)
- if snippet.id in self.loaded_ids:
- snippets_debug('Not added snippet ' + str(library.language) + \
- '::' + snippet['description'] + ' (duplicate)')
- return None
+ if snippet.id in self.loaded_ids:
+ helper.snippets_debug('Not added snippet ' + str(library.language) + \
+ '::' + snippet['description'] + ' (duplicate)')
+ return None
- snippet = container.append(snippet)
- snippets_debug('Added snippet ' + str(library.language) + '::' + \
- snippet['description'])
+ snippet = container.append(snippet)
+ helper.snippets_debug('Added snippet ' + str(library.language) + '::' + \
+ snippet['description'])
- if snippet and snippet.override:
- self.add_override(snippet)
+ if snippet and snippet.override:
+ self.add_override(snippet)
- if snippet.id:
- self.loaded_ids.append(snippet.id)
+ if snippet.id:
+ self.loaded_ids.append(snippet.id)
- return snippet
+ return snippet
- def container(self, language):
- language = self.normalize_language(language)
+ def container(self, language):
+ language = self.normalize_language(language)
- if not language in self.containers:
- self.containers[language] = LanguageContainer(language)
+ if not language in self.containers:
+ self.containers[language] = LanguageContainer(language)
- return self.containers[language]
+ return self.containers[language]
- def get_user_library(self, language):
- target = None
+ def get_user_library(self, language):
+ target = None
- if language in self.libraries:
- for library in self.libraries[language]:
- if isinstance(library, SnippetsUserFile) and library.modifier:
- target = library
- elif not isinstance(library, SnippetsUserFile):
- break
+ if language in self.libraries:
+ for library in self.libraries[language]:
+ if isinstance(library, SnippetsUserFile) and library.modifier:
+ target = library
+ elif not isinstance(library, SnippetsUserFile):
+ break
- if not target:
- # Create a new user file then
- snippets_debug('Creating a new user file for language ' + \
- str(language))
- target = SnippetsUserFile()
- target.create_root(language)
- self.add_library(target)
+ if not target:
+ # Create a new user file then
+ helper.snippets_debug('Creating a new user file for language ' + \
+ str(language))
+ target = SnippetsUserFile()
+ target.create_root(language)
+ self.add_library(target)
- return target
+ return target
- def new_snippet(self, language, properties=None):
- language = self.normalize_language(language)
- library = self.get_user_library(language)
+ def new_snippet(self, language, properties=None):
+ language = self.normalize_language(language)
+ library = self.get_user_library(language)
- return library.new_snippet(properties)
+ return library.new_snippet(properties)
- def revert_snippet(self, snippet):
- # This will revert the snippet to the one it overrides
- if not snippet.can_modify() or not snippet.override in self.overridden:
- # It can't be reverted, shouldn't happen, but oh..
- return
+ def revert_snippet(self, snippet):
+ # This will revert the snippet to the one it overrides
+ if not snippet.can_modify() or not snippet.override in self.overridden:
+ # It can't be reverted, shouldn't happen, but oh..
+ return
- # The snippet in self.overriden only contains the property contents and
- # the library it belongs to
- revertto = self.overridden[snippet.override]
- del self.overridden[snippet.override]
+ # The snippet in self.overriden only contains the property contents and
+ # the library it belongs to
+ revertto = self.overridden[snippet.override]
+ del self.overridden[snippet.override]
- if revertto:
- snippet.revert(revertto)
+ if revertto:
+ snippet.revert(revertto)
- if revertto.id:
- self.loaded_ids.append(revertto.id)
+ if revertto.id:
+ self.loaded_ids.append(revertto.id)
- def remove_snippet(self, snippet):
- if not snippet.can_modify() or snippet.is_override():
- return
+ def remove_snippet(self, snippet):
+ if not snippet.can_modify() or snippet.is_override():
+ return
- # Remove from the library
- userlib = snippet.library()
- userlib.remove(snippet.node)
+ # Remove from the library
+ userlib = snippet.library()
+ userlib.remove(snippet.node)
- # Remove from the container
- container = self.containers[userlib.language]
- container.remove(snippet)
+ # Remove from the container
+ container = self.containers[userlib.language]
+ container.remove(snippet)
- def overrided(self, library, element):
- id = NamespacedId(library.language, element.attrib.get('id')).id
+ def overrided(self, library, element):
+ id = NamespacedId(library.language, element.attrib.get('id')).id
- if id in self.overridden:
- snippet = SnippetData(element, None)
- snippet.set_node(None)
+ if id in self.overridden:
+ snippet = SnippetData(element, None)
+ snippet.set_node(None)
- self.overridden[id] = snippet
- return snippet
- else:
- return None
+ self.overridden[id] = snippet
+ return snippet
+ else:
+ return None
- def add_override(self, snippet):
- snippets_debug('Add override:', snippet.override)
- if not snippet.override in self.overridden:
- self.overridden[snippet.override] = None
+ def add_override(self, snippet):
+ helper.snippets_debug('Add override:', snippet.override)
+ if not snippet.override in self.overridden:
+ self.overridden[snippet.override] = None
- def add_library(self, library):
- library.ensure_language()
+ def add_library(self, library):
+ library.ensure_language()
- if not library.ok:
- snippets_debug('Library in wrong format, ignoring')
- return False
+ if not library.ok:
+ helper.snippets_debug('Library in wrong format, ignoring')
+ return False
- snippets_debug('Adding library (' + str(library.language) + '): ' + \
- library.path)
-
- if library.language in self.libraries:
- # Make sure all the user files are before the system files
- if isinstance(library, SnippetsUserFile):
- self.libraries[library.language].insert(0, library)
- else:
- self.libraries[library.language].append(library)
- else:
- self.libraries[library.language] = [library]
+ helper.snippets_debug('Adding library (' + str(library.language) + '): ' + \
+ library.path)
- return True
+ if library.language in self.libraries:
+ # Make sure all the user files are before the system files
+ if isinstance(library, SnippetsUserFile):
+ self.libraries[library.language].insert(0, library)
+ else:
+ self.libraries[library.language].append(library)
+ else:
+ self.libraries[library.language] = [library]
- def remove_library(self, library):
- if not library.ok:
- return
+ return True
- if library.path and os.path.isfile(library.path):
- os.unlink(library.path)
+ def remove_library(self, library):
+ if not library.ok:
+ return
- try:
- self.libraries[library.language].remove(library)
- except KeyError:
- True
+ if library.path and os.path.isfile(library.path):
+ os.unlink(library.path)
- container = self.containers[library.language]
+ try:
+ self.libraries[library.language].remove(library)
+ except KeyError:
+ True
+
+ container = self.containers[library.language]
- for snippet in list(container.snippets):
- if snippet.library() == library:
- container.remove(snippet)
+ for snippet in list(container.snippets):
+ if snippet.library() == library:
+ container.remove(snippet)
- def add_user_library(self, path):
- library = SnippetsUserFile(path)
- return self.add_library(library)
+ def add_user_library(self, path):
+ library = SnippetsUserFile(path)
+ return self.add_library(library)
- def add_system_library(self, path):
- library = SnippetsSystemFile(path)
- return self.add_library(library)
+ def add_system_library(self, path):
+ library = SnippetsSystemFile(path)
+ return self.add_library(library)
- def find_libraries(self, path, searched, addcb):
- snippets_debug("Finding in: " + path)
+ def find_libraries(self, path, searched, addcb):
+ helper.snippets_debug("Finding in: " + path)
- if not os.path.isdir(path):
- return searched
+ if not os.path.isdir(path):
+ return searched
- files = os.listdir(path)
- searched.append(path)
+ files = os.listdir(path)
+ searched.append(path)
- for f in files:
- f = os.path.realpath(os.path.join(path, f))
+ for f in files:
+ f = os.path.realpath(os.path.join(path, f))
- # Determine what language this file provides snippets for
- if os.path.isfile(f):
- addcb(f)
+ # Determine what language this file provides snippets for
+ if os.path.isfile(f):
+ addcb(f)
- return searched
+ return searched
- def normalize_language(self, language):
- if language:
- return language.lower()
+ def normalize_language(self, language):
+ if language:
+ return language.lower()
- return language
+ return language
- def remove_container(self, language):
- for snippet in self.containers[language].snippets:
- if snippet.id in self.loaded_ids:
- self.loaded_ids.remove(snippet.id)
+ def remove_container(self, language):
+ for snippet in self.containers[language].snippets:
+ if snippet.id in self.loaded_ids:
+ self.loaded_ids.remove(snippet.id)
- if snippet.override in self.overridden:
- del self.overridden[snippet.override]
+ if snippet.override in self.overridden:
+ del self.overridden[snippet.override]
- del self.containers[language]
+ del self.containers[language]
- def get_accel_group(self, language):
- language = self.normalize_language(language)
- container = self.container(language)
+ def get_accel_group(self, language):
+ language = self.normalize_language(language)
+ container = self.container(language)
- self.ensure(language)
- return container.accel_group
+ self.ensure(language)
+ return container.accel_group
- def save(self, language):
- language = self.normalize_language(language)
+ def save(self, language):
+ language = self.normalize_language(language)
- if language in self.libraries:
- for library in self.libraries[language]:
- if isinstance(library, SnippetsUserFile):
- library.save()
- else:
- break
+ if language in self.libraries:
+ for library in self.libraries[language]:
+ if isinstance(library, SnippetsUserFile):
+ library.save()
+ else:
+ break
- def ref(self, language):
- language = self.normalize_language(language)
+ def ref(self, language):
+ language = self.normalize_language(language)
- snippets_debug('Ref:', language)
- self.container(language).ref()
+ helper.snippets_debug('Ref:', language)
+ self.container(language).ref()
- def unref(self, language):
- language = self.normalize_language(language)
+ def unref(self, language):
+ language = self.normalize_language(language)
- snippets_debug('Unref:', language)
+ helper.snippets_debug('Unref:', language)
- if language in self.containers:
- if not self.containers[language].unref() and \
- language in self.libraries:
+ if language in self.containers:
+ if not self.containers[language].unref() and \
+ language in self.libraries:
- for library in self.libraries[language]:
- library.unload()
+ for library in self.libraries[language]:
+ library.unload()
- self.remove_container(language)
+ self.remove_container(language)
- def ensure(self, language):
- self.ensure_files()
- language = self.normalize_language(language)
+ def ensure(self, language):
+ self.ensure_files()
+ language = self.normalize_language(language)
- # Ensure language as well as the global snippets (None)
- for lang in (None, language):
- if lang in self.libraries:
- # Ensure the container exists
- self.container(lang)
+ # Ensure language as well as the global snippets (None)
+ for lang in (None, language):
+ if lang in self.libraries:
+ # Ensure the container exists
+ self.container(lang)
- for library in self.libraries[lang]:
- library.ensure()
+ for library in self.libraries[lang]:
+ library.ensure()
- def ensure_files(self):
- if self.loaded:
- return
+ def ensure_files(self):
+ if self.loaded:
+ return
- searched = []
- searched = self.find_libraries(self.userdir, searched, \
- self.add_user_library)
+ searched = []
+ searched = self.find_libraries(self.userdir, searched, \
+ self.add_user_library)
- for d in self.systemdirs:
- searched = self.find_libraries(d, searched, \
- self.add_system_library)
+ for d in self.systemdirs:
+ searched = self.find_libraries(d, searched, \
+ self.add_system_library)
- self.loaded = True
+ self.loaded = True
- def valid_accelerator(self, keyval, mod):
- mod &= Gtk.accelerator_get_default_mod_mask()
+ def valid_accelerator(self, keyval, mod):
+ mod &= Gtk.accelerator_get_default_mod_mask()
- return (mod and (Gdk.keyval_to_unicode(keyval) or \
- keyval in range(Gdk.KEY_F1, Gdk.KEY_F12 + 1)))
+ return (mod and (Gdk.keyval_to_unicode(keyval) or \
+ keyval in range(Gdk.KEY_F1, Gdk.KEY_F12 + 1)))
- def valid_tab_trigger(self, trigger):
- if not trigger:
- return True
+ def valid_tab_trigger(self, trigger):
+ if not trigger:
+ return True
- return is_tab_trigger(trigger)
+ return helper.is_tab_trigger(trigger)
- # Snippet getters
- # ===============
- def _from_prop(self, prop, value, language=None):
- self.ensure_files()
+ # Snippet getters
+ # ===============
+ def _from_prop(self, prop, value, language=None):
+ self.ensure_files()
- result = []
- language = self.normalize_language(language)
+ result = []
+ language = self.normalize_language(language)
- if not language in self.containers:
- return []
+ if not language in self.containers:
+ return []
- self.ensure(language)
- result = self.containers[language].from_prop(prop, value)
+ self.ensure(language)
+ result = self.containers[language].from_prop(prop, value)
- if len(result) == 0 and language and None in self.containers:
- result = self.containers[None].from_prop(prop, value)
+ if len(result) == 0 and language and None in self.containers:
+ result = self.containers[None].from_prop(prop, value)
- return result
+ return result
- # Get snippets for a given language
- def get_snippets(self, language=None):
- self.ensure_files()
- language = self.normalize_language(language)
+ # Get snippets for a given language
+ def get_snippets(self, language=None):
+ self.ensure_files()
+ language = self.normalize_language(language)
- if not language in self.libraries:
- return []
+ if not language in self.libraries:
+ return []
- snippets = []
- self.ensure(language)
+ self.ensure(language)
- return list(self.containers[language].snippets)
+ return list(self.containers[language].snippets)
- # Get snippets for a given accelerator
- def from_accelerator(self, accelerator, language=None):
- return self._from_prop('accelerator', accelerator, language)
+ # Get snippets for a given accelerator
+ def from_accelerator(self, accelerator, language=None):
+ return self._from_prop('accelerator', accelerator, language)
- # Get snippets for a given tag
- def from_tag(self, tag, language=None):
- return self._from_prop('tag', tag, language)
+ # Get snippets for a given tag
+ def from_tag(self, tag, language=None):
+ return self._from_prop('tag', tag, language)
- # Get snippets for a given drop target
- def from_drop_target(self, drop_target, language=None):
- return self._from_prop('drop-targets', drop_target, language)
+ # Get snippets for a given drop target
+ def from_drop_target(self, drop_target, language=None):
+ return self._from_prop('drop-targets', drop_target, language)
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/manager.py b/plugins/snippets/snippets/manager.py
index afef51f..3eb28e6 100644
--- a/plugins/snippets/snippets/manager.py
+++ b/plugins/snippets/snippets/manager.py
@@ -19,1123 +19,1117 @@ import os
import tempfile
import shutil
-from gi.repository import Gtk, Gio, Gdk, GtkSource, Gedit, GObject
+from gi.repository import Gtk, Gio, Gdk, GObject
from .snippet import Snippet
-from .helper import *
-from .library import *
-from .importer import *
-from .exporter import *
-from .document import Document
+from . import helper
+from .library import Library
+from .importer import Importer
+from .exporter import Exporter
from .languagemanager import get_language_manager
class Manager(Gtk.Window, Gtk.Buildable):
- NAME_COLUMN = 0
- SORT_COLUMN = 1
- LANG_COLUMN = 2
- SNIPPET_COLUMN = 3
- TARGET_URI = 105
+ NAME_COLUMN = 0
+ SORT_COLUMN = 1
+ LANG_COLUMN = 2
+ SNIPPET_COLUMN = 3
+ TARGET_URI = 105
- __gtype_name__ = "GeditSnippetsManager"
+ __gtype_name__ = "GeditSnippetsManager"
- model = None
- drag_icons = ('gnome-mime-application-x-tarz', 'gnome-package', 'package')
- default_export_name = _('Snippets archive') + '.tar.gz'
- dragging = False
+ model = None
+ drag_icons = ('gnome-mime-application-x-tarz', 'gnome-package', 'package')
+ default_export_name = _('Snippets archive') + '.tar.gz'
+ dragging = False
- def __init__(self):
- self.snippet = None
- self._temp_export = None
- self._size = (0, 0)
+ def __init__(self):
+ self.snippet = None
+ self._temp_export = None
+ self._size = (0, 0)
- self.key_press_id = 0
- self.dnd_target_list = Gtk.TargetList.new([])
- self.dnd_target_list.add(Gdk.atom_intern("text/uri-list", True), 0, self.TARGET_URI)
+ self.key_press_id = 0
+ self.dnd_target_list = Gtk.TargetList.new([])
+ self.dnd_target_list.add(Gdk.atom_intern("text/uri-list", True), 0, self.TARGET_URI)
- def get_final_size(self):
- return self._size
+ def get_final_size(self):
+ return self._size
- def get_language_snippets(self, path, name = None):
- library = Library()
+ def get_language_snippets(self, path, name = None):
+ library = Library()
- name = self.get_language(path)
- nodes = library.get_snippets(name)
+ name = self.get_language(path)
+ nodes = library.get_snippets(name)
- return nodes
+ return nodes
- def add_new_snippet_node(self, parent):
- return self.model.append(parent, ('<i>' + _('Add a new snippet...') + \
- '</i>', '', None, None))
+ def add_new_snippet_node(self, parent):
+ return self.model.append(parent, ('<i>' + _('Add a new snippet...') + \
+ '</i>', '', None, None))
- def fill_language(self, piter, expand=True):
- # Remove all children
- child = self.model.iter_children(piter)
+ def fill_language(self, piter, expand=True):
+ # Remove all children
+ child = self.model.iter_children(piter)
- while child and self.model.remove(child):
- True
+ while child and self.model.remove(child):
+ True
- path = self.model.get_path(piter)
- nodes = self.get_language_snippets(path)
- language = self.get_language(path)
+ path = self.model.get_path(piter)
+ nodes = self.get_language_snippets(path)
+ language = self.get_language(path)
- Library().ref(language)
+ Library().ref(language)
- if nodes:
- for node in nodes:
- self.add_snippet(piter, node)
- else:
- # Add node that tells there are no snippets currently
- self.add_new_snippet_node(piter)
-
- if expand:
- self.tree_view.expand_row(path, False)
-
- def build_model(self, force_reload = False):
- window = Gio.Application.get_default().get_active_window()
- if window:
- view = window.get_active_view()
-
- if not view:
- current_lang = None
- else:
- current_lang = view.get_buffer().get_language()
- source_view = self['source_view_snippet']
-
- else:
- current_lang = None
-
- tree_view = self['tree_view_snippets']
- expand = None
-
- if not self.model or force_reload:
- self.model = Gtk.TreeStore(str, str, GObject.Object, object)
- self.model.set_sort_column_id(self.SORT_COLUMN, Gtk.SortType.ASCENDING)
-
- manager = get_language_manager()
-
- langs = [manager.get_language(x) for x in manager.get_language_ids()]
- langs.sort(key=lambda x: x.get_name())
-
- piter = self.model.append(None, (_('Global'), '', None, None))
-
- # Add dummy node
- self.model.append(piter, ('', '', None, None))
-
- nm = None
-
- if current_lang:
- nm = current_lang.get_name()
-
- for lang in langs:
- name = lang.get_name()
- parent = self.model.append(None, (name, name, lang, None))
-
- # Add dummy node
- self.model.append(parent, ('', '', None, None))
+ if nodes:
+ for node in nodes:
+ self.add_snippet(piter, node)
+ else:
+ # Add node that tells there are no snippets currently
+ self.add_new_snippet_node(piter)
- if (nm == name):
- expand = parent
- else:
- if current_lang:
- piter = self.model.get_iter_first()
- nm = current_lang.get_name()
-
- while piter:
- lang = self.model.get_value(piter, \
- self.SORT_COLUMN)
+ if expand:
+ self.tree_view.expand_row(path, False)
- if lang == nm:
- expand = piter
- break;
+ def build_model(self, force_reload = False):
+ window = Gio.Application.get_default().get_active_window()
+ if window:
+ view = window.get_active_view()
- piter = self.model.iter_next(piter)
+ if not view:
+ current_lang = None
+ else:
+ current_lang = view.get_buffer().get_language()
+ else:
+ current_lang = None
- tree_view.set_model(self.model)
+ tree_view = self['tree_view_snippets']
+ expand = None
- if not expand:
- expand = self.model.get_iter_first()
+ if not self.model or force_reload:
+ self.model = Gtk.TreeStore(str, str, GObject.Object, object)
+ self.model.set_sort_column_id(self.SORT_COLUMN, Gtk.SortType.ASCENDING)
- tree_view.expand_row(self.model.get_path(expand), False)
- self.select_iter(expand)
+ manager = get_language_manager()
- def get_cell_data_pixbuf_cb(self, column, cell, model, iter, data):
- lang = model.get_value(iter, self.LANG_COLUMN)
- snippet = model.get_value(iter, self.SNIPPET_COLUMN)
-
- if snippet and not snippet.valid:
- cell.set_property('icon-name', 'dialog-error')
- else:
- cell.set_property('icon-name', None)
+ langs = [manager.get_language(x) for x in manager.get_language_ids()]
+ langs.sort(key=lambda x: x.get_name())
- cell.set_property('xalign', 1.0)
+ piter = self.model.append(None, (_('Global'), '', None, None))
- def get_cell_data_cb(self, column, cell, model, iter, data):
- snippet = model.get_value(iter, self.SNIPPET_COLUMN)
+ # Add dummy node
+ self.model.append(piter, ('', '', None, None))
- cell.set_property('editable', snippet != None)
- cell.set_property('markup', model.get_value(iter, self.NAME_COLUMN))
+ nm = None
- def on_tree_view_drag_data_get(self, widget, context, selection_data, info, time):
- gfile = Gio.file_new_for_path(self._temp_export)
- selection_data.set_uris([gfile.get_uri()])
+ if current_lang:
+ nm = current_lang.get_name()
- def on_tree_view_drag_begin(self, widget, context):
- self.dragging = True
+ for lang in langs:
+ name = lang.get_name()
+ parent = self.model.append(None, (name, name, lang, None))
- if self._temp_export:
- shutil.rmtree(os.path.dirname(self._temp_export))
- self._temp_export = None
+ # Add dummy node
+ self.model.append(parent, ('', '', None, None))
- if self.dnd_name:
- Gtk.drag_set_icon_name(context, self.dnd_name, 0, 0)
+ if (nm == name):
+ expand = parent
+ else:
+ if current_lang:
+ piter = self.model.get_iter_first()
+ nm = current_lang.get_name()
- dirname = tempfile.mkdtemp()
- filename = os.path.join(dirname, self.default_export_name)
+ while piter:
+ lang = self.model.get_value(piter, \
+ self.SORT_COLUMN)
- # Generate temporary file name
- self.export_snippets(filename, False)
- self._temp_export = filename
+ if lang == nm:
+ expand = piter
+ break;
- def on_tree_view_drag_end(self, widget, context):
- self.dragging = False
+ piter = self.model.iter_next(piter)
- def on_tree_view_drag_data_received(self, widget, context, x, y, selection, info, timestamp):
- uris = selection.get_uris()
+ tree_view.set_model(self.model)
- files = [Gio.file_new_for_uri(x) for x in uris]
+ if not expand:
+ expand = self.model.get_iter_first()
- self.import_snippets(files)
+ tree_view.expand_row(self.model.get_path(expand), False)
+ self.select_iter(expand)
- def on_tree_view_drag_motion(self, widget, context, x, y, timestamp):
- # Return False if we are dragging
- if self.dragging:
- return False
+ def get_cell_data_pixbuf_cb(self, column, cell, model, iter, data):
+ snippet = model.get_value(iter, self.SNIPPET_COLUMN)
- # Check uri target
- if not Gtk.targets_include_uri(context.targets):
- return False
+ if snippet and not snippet.valid:
+ cell.set_property('icon-name', 'dialog-error')
+ else:
+ cell.set_property('icon-name', None)
- # Check action
- action = None
- if context.suggested_action == Gdk.DragAction.COPY:
- action = Gdk.DragAction.COPY
- else:
- for act in context.actions:
- if act == Gdk.DragAction.COPY:
- action = Gdk.DragAction.COPY
- break
-
- if action == Gdk.DragAction.COPY:
- context.drag_status(Gdk.DragAction.COPY, timestamp)
- return True
- else:
- return False
+ cell.set_property('xalign', 1.0)
- def build_dnd(self):
- tv = self.tree_view
+ def get_cell_data_cb(self, column, cell, model, iter, data):
+ snippet = model.get_value(iter, self.SNIPPET_COLUMN)
- # Set it as a drag source for exporting snippets
- tv.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, [], Gdk.DragAction.DEFAULT |
Gdk.DragAction.COPY)
- tv.drag_source_set_target_list(self.dnd_target_list)
+ cell.set_property('editable', snippet != None)
+ cell.set_property('markup', model.get_value(iter, self.NAME_COLUMN))
- # Set it as a drag destination for importing snippets
- tv.drag_dest_set(Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
- [], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY)
+ def on_tree_view_drag_data_get(self, widget, context, selection_data, info, time):
+ gfile = Gio.file_new_for_path(self._temp_export)
+ selection_data.set_uris([gfile.get_uri()])
- tv.drag_dest_set_target_list(self.dnd_target_list)
+ def on_tree_view_drag_begin(self, widget, context):
+ self.dragging = True
- tv.connect('drag_data_get', self.on_tree_view_drag_data_get)
- tv.connect('drag_begin', self.on_tree_view_drag_begin)
- tv.connect('drag_end', self.on_tree_view_drag_end)
- tv.connect('drag_data_received', self.on_tree_view_drag_data_received)
- tv.connect('drag_motion', self.on_tree_view_drag_motion)
+ if self._temp_export:
+ shutil.rmtree(os.path.dirname(self._temp_export))
+ self._temp_export = None
- theme = Gtk.IconTheme.get_for_screen(tv.get_screen())
+ if self.dnd_name:
+ Gtk.drag_set_icon_name(context, self.dnd_name, 0, 0)
- self.dnd_name = None
- for name in self.drag_icons:
- icon = theme.lookup_icon(name, Gtk.IconSize.DND, 0)
+ dirname = tempfile.mkdtemp()
+ filename = os.path.join(dirname, self.default_export_name)
- if icon:
- self.dnd_name = name
- break
+ # Generate temporary file name
+ self.export_snippets(filename, False)
+ self._temp_export = filename
- def build_tree_view(self):
- self.tree_view = self['tree_view_snippets']
+ def on_tree_view_drag_end(self, widget, context):
+ self.dragging = False
- self.column = Gtk.TreeViewColumn(None)
+ def on_tree_view_drag_data_received(self, widget, context, x, y, selection, info, timestamp):
+ uris = selection.get_uris()
- self.renderer = Gtk.CellRendererText()
- self.column.pack_start(self.renderer, False)
- self.column.set_cell_data_func(self.renderer, self.get_cell_data_cb, None)
+ files = [Gio.file_new_for_uri(u) for u in uris]
- renderer = Gtk.CellRendererPixbuf()
- self.column.pack_start(renderer, True)
- self.column.set_cell_data_func(renderer, self.get_cell_data_pixbuf_cb, None)
+ self.import_snippets(files)
- self.tree_view.append_column(self.column)
+ def on_tree_view_drag_motion(self, widget, context, x, y, timestamp):
+ # Return False if we are dragging
+ if self.dragging:
+ return False
- self.renderer.connect('edited', self.on_cell_edited)
- self.renderer.connect('editing-started', self.on_cell_editing_started)
+ # Check uri target
+ if not Gtk.targets_include_uri(context.targets):
+ return False
- selection = self.tree_view.get_selection()
- selection.set_mode(Gtk.SelectionMode.MULTIPLE)
- selection.connect('changed', self.on_tree_view_selection_changed)
+ # Check action
+ action = None
+ if context.suggested_action == Gdk.DragAction.COPY:
+ action = Gdk.DragAction.COPY
+ else:
+ for act in context.actions:
+ if act == Gdk.DragAction.COPY:
+ action = Gdk.DragAction.COPY
+ break
- self.build_dnd()
+ if action == Gdk.DragAction.COPY:
+ context.drag_status(Gdk.DragAction.COPY, timestamp)
+ return True
+ else:
+ return False
- def do_parser_finished(self, builder):
- self.builder = builder
+ def build_dnd(self):
+ tv = self.tree_view
- handlers_dic = {
- 'on_add_snippet_button_clicked': self.on_add_snippet_button_clicked,
- 'on_remove_snippet_button_clicked': self.on_remove_snippet_button_clicked,
- 'on_import_snippets_button_clicked': self.on_import_snippets_button_clicked,
- 'on_export_snippets_button_clicked': self.on_export_snippets_button_clicked,
- 'on_entry_tab_trigger_focus_out': self.on_entry_tab_trigger_focus_out,
- 'on_entry_tab_trigger_changed': self.on_entry_tab_trigger_changed,
- 'on_entry_accelerator_focus_out': self.on_entry_accelerator_focus_out,
- 'on_entry_accelerator_focus_in': self.on_entry_accelerator_focus_in,
- 'on_entry_accelerator_key_press': self.on_entry_accelerator_key_press,
- 'on_source_view_snippet_focus_out': self.on_source_view_snippet_focus_out,
- 'on_tree_view_snippets_row_expanded': self.on_tree_view_snippets_row_expanded,
- 'on_tree_view_snippets_key_press': self.on_tree_view_snippets_key_press}
+ # Set it as a drag source for exporting snippets
+ tv.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, [], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY)
+ tv.drag_source_set_target_list(self.dnd_target_list)
- self.builder.connect_signals(handlers_dic)
+ # Set it as a drag destination for importing snippets
+ tv.drag_dest_set(Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
+ [], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY)
- self.build_tree_view()
- self.build_model()
+ tv.drag_dest_set_target_list(self.dnd_target_list)
- # join treeview and toolbar
- context = self['scrolled_window_snippets'].get_style_context()
- context.set_junction_sides(Gtk.JunctionSides.BOTTOM)
- context = self['toolbar'].get_style_context()
- context.set_junction_sides(Gtk.JunctionSides.TOP)
- context.set_junction_sides(Gtk.JunctionSides.BOTTOM)
+ tv.connect('drag_data_get', self.on_tree_view_drag_data_get)
+ tv.connect('drag_begin', self.on_tree_view_drag_begin)
+ tv.connect('drag_end', self.on_tree_view_drag_end)
+ tv.connect('drag_data_received', self.on_tree_view_drag_data_received)
+ tv.connect('drag_motion', self.on_tree_view_drag_motion)
- source_view = self['source_view_snippet']
- manager = get_language_manager()
- lang = manager.get_language('snippets')
+ theme = Gtk.IconTheme.get_for_screen(tv.get_screen())
- if lang:
- source_view.get_buffer().set_highlight_syntax(True)
- source_view.get_buffer().set_language(lang)
+ self.dnd_name = None
+ for name in self.drag_icons:
+ icon = theme.lookup_icon(name, Gtk.IconSize.DND, 0)
- combo = self['combo_drop_targets']
+ if icon:
+ self.dnd_name = name
+ break
- entry = combo.get_child()
- entry.connect('focus-out-event', self.on_entry_drop_targets_focus_out)
- entry.connect('drag-data-received', self.on_entry_drop_targets_drag_data_received)
+ def build_tree_view(self):
+ self.tree_view = self['tree_view_snippets']
- lst = entry.drag_dest_get_target_list()
- lst.add_uri_targets(self.TARGET_URI)
+ self.column = Gtk.TreeViewColumn(None)
- def do_configure_event(self, event):
- if self.get_realized():
- alloc = self.get_allocation()
- self._size = (alloc.width, alloc.height)
+ self.renderer = Gtk.CellRendererText()
+ self.column.pack_start(self.renderer, False)
+ self.column.set_cell_data_func(self.renderer, self.get_cell_data_cb, None)
- return Gtk.Dialog.do_configure_event(self, event)
+ renderer = Gtk.CellRendererPixbuf()
+ self.column.pack_start(renderer, True)
+ self.column.set_cell_data_func(renderer, self.get_cell_data_pixbuf_cb, None)
- def __getitem__(self, key):
- return self.builder.get_object(key)
+ self.tree_view.append_column(self.column)
- def is_filled(self, piter):
- if not self.model.iter_has_child(piter):
- return True
+ self.renderer.connect('edited', self.on_cell_edited)
+ self.renderer.connect('editing-started', self.on_cell_editing_started)
- child = self.model.iter_children(piter)
- nm = self.model.get_value(child, self.NAME_COLUMN)
- lang = self.model.get_value(child, self.LANG_COLUMN)
- snippet = self.model.get_value(child, self.SNIPPET_COLUMN)
+ selection = self.tree_view.get_selection()
+ selection.set_mode(Gtk.SelectionMode.MULTIPLE)
+ selection.connect('changed', self.on_tree_view_selection_changed)
- return (lang or snippet or nm)
+ self.build_dnd()
- def fill_if_needed(self, piter, expand=True):
- if not self.is_filled(piter):
- self.fill_language(piter, expand)
+ def do_parser_finished(self, builder):
+ self.builder = builder
- def find_iter(self, parent, snippet):
- self.fill_if_needed(parent)
- piter = self.model.iter_children(parent)
+ handlers_dic = {
+ 'on_add_snippet_button_clicked': self.on_add_snippet_button_clicked,
+ 'on_remove_snippet_button_clicked': self.on_remove_snippet_button_clicked,
+ 'on_import_snippets_button_clicked': self.on_import_snippets_button_clicked,
+ 'on_export_snippets_button_clicked': self.on_export_snippets_button_clicked,
+ 'on_entry_tab_trigger_focus_out': self.on_entry_tab_trigger_focus_out,
+ 'on_entry_tab_trigger_changed': self.on_entry_tab_trigger_changed,
+ 'on_entry_accelerator_focus_out': self.on_entry_accelerator_focus_out,
+ 'on_entry_accelerator_focus_in': self.on_entry_accelerator_focus_in,
+ 'on_entry_accelerator_key_press': self.on_entry_accelerator_key_press,
+ 'on_source_view_snippet_focus_out': self.on_source_view_snippet_focus_out,
+ 'on_tree_view_snippets_row_expanded': self.on_tree_view_snippets_row_expanded,
+ 'on_tree_view_snippets_key_press': self.on_tree_view_snippets_key_press}
- while (piter):
- sn = self.model.get_value(piter, self.SNIPPET_COLUMN)
+ self.builder.connect_signals(handlers_dic)
- if sn == snippet.data:
- return piter
+ self.build_tree_view()
+ self.build_model()
- piter = self.model.iter_next(piter)
+ # join treeview and toolbar
+ context = self['scrolled_window_snippets'].get_style_context()
+ context.set_junction_sides(Gtk.JunctionSides.BOTTOM)
+ context = self['toolbar'].get_style_context()
+ context.set_junction_sides(Gtk.JunctionSides.TOP)
+ context.set_junction_sides(Gtk.JunctionSides.BOTTOM)
- return None
+ source_view = self['source_view_snippet']
+ manager = get_language_manager()
+ lang = manager.get_language('snippets')
- def selected_snippets_state(self):
- snippets = self.selected_snippets(False)
- override = False
- remove = False
- system = False
+ if lang:
+ source_view.get_buffer().set_highlight_syntax(True)
+ source_view.get_buffer().set_language(lang)
- for snippet in snippets:
- if not snippet:
- continue
+ combo = self['combo_drop_targets']
- if snippet.is_override():
- override = True
- elif snippet.can_modify():
- remove = True
- else:
- system = True
+ entry = combo.get_child()
+ entry.connect('focus-out-event', self.on_entry_drop_targets_focus_out)
+ entry.connect('drag-data-received', self.on_entry_drop_targets_drag_data_received)
- # No need to continue if both are found
- if override and remove:
- break
+ lst = entry.drag_dest_get_target_list()
+ lst.add_uri_targets(self.TARGET_URI)
- return (override, remove, system)
+ def do_configure_event(self, event):
+ if self.get_realized():
+ alloc = self.get_allocation()
+ self._size = (alloc.width, alloc.height)
- def update_toolbar_buttons(self):
- button_add = self['add_snippet_button']
- button_remove = self['remove_snippet_button']
+ return Gtk.Dialog.do_configure_event(self, event)
- button_add.set_sensitive(self.language_path != None)
- override, remove, system = self.selected_snippets_state()
+ def __getitem__(self, key):
+ return self.builder.get_object(key)
- if not (override ^ remove) or system:
- button_remove.set_sensitive(False)
- button_remove.set_icon_name('list-remove-symbolic')
- else:
- button_remove.set_sensitive(True)
+ def is_filled(self, piter):
+ if not self.model.iter_has_child(piter):
+ return True
- if override:
- button_remove.set_icon_name('edit-undo-symbolic')
- tooltip = _('Revert selected snippet')
- else:
- button_remove.set_icon_name('list-remove-symbolic')
- tooltip = _('Delete selected snippet')
+ child = self.model.iter_children(piter)
+ nm = self.model.get_value(child, self.NAME_COLUMN)
+ lang = self.model.get_value(child, self.LANG_COLUMN)
+ snippet = self.model.get_value(child, self.SNIPPET_COLUMN)
- button_remove.set_tooltip_text(tooltip)
+ return (lang or snippet or nm)
- def snippet_changed(self, piter = None):
- if piter:
- node = self.model.get_value(piter, self.SNIPPET_COLUMN)
- s = Snippet(node)
- else:
- s = self.snippet
- piter = self.find_iter(self.model.get_iter(self.language_path), s)
+ def fill_if_needed(self, piter, expand=True):
+ if not self.is_filled(piter):
+ self.fill_language(piter, expand)
- if piter:
- nm = s.display()
+ def find_iter(self, parent, snippet):
+ self.fill_if_needed(parent)
+ piter = self.model.iter_children(parent)
- self.model.set_value(piter, self.NAME_COLUMN, nm)
- self.model.set_value(piter, self.SORT_COLUMN, nm)
- self.update_toolbar_buttons()
- self.entry_tab_trigger_update_valid()
+ while (piter):
+ sn = self.model.get_value(piter, self.SNIPPET_COLUMN)
+ if sn == snippet.data:
return piter
- def add_snippet(self, parent, snippet):
- piter = self.model.append(parent, ('', '', None, snippet))
+ piter = self.model.iter_next(piter)
- return self.snippet_changed(piter)
+ return None
- def snippet_from_iter(self, model, piter):
- parent = model.iter_parent(piter)
+ def selected_snippets_state(self):
+ snippets = self.selected_snippets(False)
+ override = False
+ remove = False
+ system = False
- if parent:
- return model.get_value(piter, self.SNIPPET_COLUMN)
- else:
- return None
+ for snippet in snippets:
+ if not snippet:
+ continue
- def language_snippets(self, model, parent, as_path=False):
- self.fill_if_needed(parent, False)
- piter = model.iter_children(parent)
- snippets = []
+ if snippet.is_override():
+ override = True
+ elif snippet.can_modify():
+ remove = True
+ else:
+ system = True
- if not piter:
- return snippets
+ # No need to continue if both are found
+ if override and remove:
+ break
- while piter:
- snippet = self.snippet_from_iter(model, piter)
+ return (override, remove, system)
- if snippet:
- if as_path:
- snippets.append(model.get_path(piter))
- else:
- snippets.append(snippet)
+ def update_toolbar_buttons(self):
+ button_add = self['add_snippet_button']
+ button_remove = self['remove_snippet_button']
- piter = model.iter_next(piter)
+ button_add.set_sensitive(self.language_path != None)
+ override, remove, system = self.selected_snippets_state()
- return snippets
+ if not (override ^ remove) or system:
+ button_remove.set_sensitive(False)
+ button_remove.set_icon_name('list-remove-symbolic')
+ else:
+ button_remove.set_sensitive(True)
- def selected_snippets(self, include_languages=True, as_path=False):
- selection = self.tree_view.get_selection()
- (model, paths) = selection.get_selected_rows()
- snippets = []
+ if override:
+ button_remove.set_icon_name('edit-undo-symbolic')
+ tooltip = _('Revert selected snippet')
+ else:
+ button_remove.set_icon_name('list-remove-symbolic')
+ tooltip = _('Delete selected snippet')
- if paths and len(paths) != 0:
- for p in paths:
- piter = model.get_iter(p)
- parent = model.iter_parent(piter)
+ button_remove.set_tooltip_text(tooltip)
- if not piter:
- continue
+ def snippet_changed(self, piter = None):
+ if piter:
+ node = self.model.get_value(piter, self.SNIPPET_COLUMN)
+ s = Snippet(node)
+ else:
+ s = self.snippet
+ piter = self.find_iter(self.model.get_iter(self.language_path), s)
- if parent:
- snippet = self.snippet_from_iter(model, piter)
+ if piter:
+ nm = s.display()
- if not snippet:
- continue
+ self.model.set_value(piter, self.NAME_COLUMN, nm)
+ self.model.set_value(piter, self.SORT_COLUMN, nm)
+ self.update_toolbar_buttons()
+ self.entry_tab_trigger_update_valid()
- if as_path:
- snippets.append(p)
- else:
- snippets.append(snippet)
- elif include_languages:
- snippets += self.language_snippets(model, piter, as_path)
+ return piter
- return snippets
+ def add_snippet(self, parent, snippet):
+ piter = self.model.append(parent, ('', '', None, snippet))
- def selected_snippet(self):
- selection = self.tree_view.get_selection()
- (model, paths) = selection.get_selected_rows()
+ return self.snippet_changed(piter)
- if len(paths) == 1:
- piter = model.get_iter(paths[0])
- parent = model.iter_parent(piter)
- snippet = self.snippet_from_iter(model, piter)
+ def snippet_from_iter(self, model, piter):
+ parent = model.iter_parent(piter)
- return parent, piter, snippet
- else:
- return None, None, None
+ if parent:
+ return model.get_value(piter, self.SNIPPET_COLUMN)
+ else:
+ return None
- def selection_changed(self):
- if not self.snippet:
- sens = False
+ def language_snippets(self, model, parent, as_path=False):
+ self.fill_if_needed(parent, False)
+ piter = model.iter_children(parent)
+ snippets = []
- self['entry_tab_trigger'].set_text('')
- self['entry_accelerator'].set_text('')
- buf = self['source_view_snippet'].get_buffer()
- buf.begin_not_undoable_action()
- buf.set_text('')
- buf.end_not_undoable_action()
- self['combo_drop_targets'].get_child().set_text('')
+ if not piter:
+ return snippets
+ while piter:
+ snippet = self.snippet_from_iter(model, piter)
+
+ if snippet:
+ if as_path:
+ snippets.append(model.get_path(piter))
else:
- sens = True
+ snippets.append(snippet)
- self['entry_tab_trigger'].set_text(self.snippet['tag'])
- self['entry_accelerator'].set_text( \
- self.snippet.accelerator_display())
- self['combo_drop_targets'].get_child().set_text(',
'.join(self.snippet['drop-targets']))
+ piter = model.iter_next(piter)
- buf = self['source_view_snippet'].get_buffer()
- buf.begin_not_undoable_action()
- buf.set_text(self.snippet['text'])
- buf.end_not_undoable_action()
+ return snippets
+ def selected_snippets(self, include_languages=True, as_path=False):
+ selection = self.tree_view.get_selection()
+ (model, paths) = selection.get_selected_rows()
+ snippets = []
- for name in ['source_view_snippet', 'label_tab_trigger',
- 'entry_tab_trigger', 'label_accelerator',
- 'entry_accelerator', 'label_drop_targets',
- 'combo_drop_targets']:
- self[name].set_sensitive(sens)
+ if paths and len(paths) != 0:
+ for p in paths:
+ piter = model.get_iter(p)
+ parent = model.iter_parent(piter)
- self.update_toolbar_buttons()
+ if not piter:
+ continue
- def select_iter(self, piter, unselect=True):
- selection = self.tree_view.get_selection()
+ if parent:
+ snippet = self.snippet_from_iter(model, piter)
- if unselect:
- selection.unselect_all()
+ if not snippet:
+ continue
- selection.select_iter(piter)
+ if as_path:
+ snippets.append(p)
+ else:
+ snippets.append(snippet)
+ elif include_languages:
+ snippets += self.language_snippets(model, piter, as_path)
- self.tree_view.scroll_to_cell(self.model.get_path(piter), None, \
- True, 0.5, 0.5)
+ return snippets
- def get_language(self, path):
- if path.get_indices()[0] == 0:
- return None
- else:
- return self.model.get_value(self.model.get_iter(path),
- self.LANG_COLUMN).get_id()
+ def selected_snippet(self):
+ selection = self.tree_view.get_selection()
+ (model, paths) = selection.get_selected_rows()
- def new_snippet(self, properties=None):
- if not self.language_path:
- return None
+ if len(paths) == 1:
+ piter = model.get_iter(paths[0])
+ parent = model.iter_parent(piter)
+ snippet = self.snippet_from_iter(model, piter)
- snippet = Library().new_snippet(self.get_language(self.language_path), properties)
+ return parent, piter, snippet
+ else:
+ return None, None, None
- return Snippet(snippet)
+ def selection_changed(self):
+ if not self.snippet:
+ sens = False
- def get_dummy(self, parent):
- if not self.model.iter_n_children(parent) == 1:
- return None
+ self['entry_tab_trigger'].set_text('')
+ self['entry_accelerator'].set_text('')
+ buf = self['source_view_snippet'].get_buffer()
+ buf.begin_not_undoable_action()
+ buf.set_text('')
+ buf.end_not_undoable_action()
+ self['combo_drop_targets'].get_child().set_text('')
- dummy = self.model.iter_children(parent)
+ else:
+ sens = True
- if not self.model.get_value(dummy, self.SNIPPET_COLUMN):
- return dummy
+ self['entry_tab_trigger'].set_text(self.snippet['tag'])
+ self['entry_accelerator'].set_text( \
+ self.snippet.accelerator_display())
+ self['combo_drop_targets'].get_child().set_text(', '.join(self.snippet['drop-targets']))
- return None
+ buf = self['source_view_snippet'].get_buffer()
+ buf.begin_not_undoable_action()
+ buf.set_text(self.snippet['text'])
+ buf.end_not_undoable_action()
- def unref_languages(self):
- piter = self.model.get_iter_first()
- library = Library()
- while piter:
- if self.is_filled(piter):
- language = self.get_language(self.model.get_path(piter))
- library.save(language)
-
- library.unref(language)
-
- piter = self.model.iter_next(piter)
-
- # Callbacks
- def do_destroy(self):
- Gtk.Dialog.do_destroy(self)
-
- if not self.model:
- return
-
- # Remove temporary drag export
- if self._temp_export:
- shutil.rmtree(os.path.dirname(self._temp_export))
- self._temp_export = None
-
- self.unref_languages()
- self.snippet = None
- self.model = None
-
- def on_cell_editing_started(self, renderer, editable, path):
- piter = self.model.get_iter(path)
-
- if not self.model.iter_parent(piter):
- renderer.stop_editing(True)
- editable.remove_widget()
- elif isinstance(editable, Gtk.Entry):
- if self.snippet:
- editable.set_text(self.snippet['description'])
- else:
- # This is the `Add a new snippet...` item
- editable.set_text('')
-
- editable.grab_focus()
-
- def on_cell_edited(self, cell, path, new_text):
- if new_text != '':
- piter = self.model.get_iter(path)
- node = self.model.get_value(piter, self.SNIPPET_COLUMN)
-
- if node:
- if node == self.snippet.data:
- s = self.snippet
- else:
- s = Snippet(node)
-
- s['description'] = new_text
- self.snippet_changed(piter)
- self.select_iter(piter)
- else:
- # This is the `Add a new snippet...` item
- # We create a new snippet
- snippet = self.new_snippet({'description': new_text})
-
- if snippet:
- self.model.set_value(piter, self.SNIPPET_COLUMN, snippet.data)
- self.snippet_changed(piter)
- self.snippet = snippet
- self.selection_changed()
-
- def on_entry_accelerator_focus_out(self, entry, event):
- if not self.snippet:
- return
-
- entry.set_text(self.snippet.accelerator_display())
-
- def entry_tab_trigger_update_valid(self):
- entry = self['entry_tab_trigger']
- text = entry.get_text()
-
- if text and not Library().valid_tab_trigger(text):
- img = self['image_tab_trigger']
- img.set_from_icon_name('dialog-error', Gtk.IconSize.BUTTON)
- img.show()
-
- #self['hbox_tab_trigger'].set_spacing(3)
- tip = _('This is not a valid Tab trigger. Triggers can either contain alphanumeric
characters (or _, : and .) or a single (non-alphanumeric) character like: {, [, etc.')
-
- entry.set_tooltip_text(tip)
- img.set_tooltip_text(tip)
- else:
- self['image_tab_trigger'].hide()
- #self['hbox_tab_trigger'].set_spacing(0)
- entry.set_tooltip_text(_('Single word the snippet is activated with after pressing
Tab'))
+ for name in ['source_view_snippet', 'label_tab_trigger',
+ 'entry_tab_trigger', 'label_accelerator',
+ 'entry_accelerator', 'label_drop_targets',
+ 'combo_drop_targets']:
+ self[name].set_sensitive(sens)
- return False
+ self.update_toolbar_buttons()
- def on_entry_tab_trigger_focus_out(self, entry, event):
- if not self.snippet:
- return
+ def select_iter(self, piter, unselect=True):
+ selection = self.tree_view.get_selection()
- text = entry.get_text()
+ if unselect:
+ selection.unselect_all()
- # save tag
- self.snippet['tag'] = text
- self.snippet_changed()
+ selection.select_iter(piter)
- def on_entry_drop_targets_focus_out(self, entry, event):
- if not self.snippet:
- return
+ self.tree_view.scroll_to_cell(self.model.get_path(piter), None, \
+ True, 0.5, 0.5)
- text = entry.get_text()
+ def get_language(self, path):
+ if path.get_indices()[0] == 0:
+ return None
+ else:
+ return self.model.get_value(self.model.get_iter(path),
+ self.LANG_COLUMN).get_id()
- # save drop targets
- self.snippet['drop-targets'] = text
- self.snippet_changed()
+ def new_snippet(self, properties=None):
+ if not self.language_path:
+ return None
- def on_entry_tab_trigger_changed(self, entry):
- self.entry_tab_trigger_update_valid()
+ snippet = Library().new_snippet(self.get_language(self.language_path), properties)
- def on_source_view_snippet_focus_out(self, source_view, event):
- if not self.snippet:
- return
+ return Snippet(snippet)
- buf = source_view.get_buffer()
- text = buf.get_text(buf.get_start_iter(), \
- buf.get_end_iter(), False)
+ def get_dummy(self, parent):
+ if not self.model.iter_n_children(parent) == 1:
+ return None
- self.snippet['text'] = text
- self.snippet_changed()
+ dummy = self.model.iter_children(parent)
- def on_add_snippet_button_clicked(self, button):
- snippet = self.new_snippet()
+ if not self.model.get_value(dummy, self.SNIPPET_COLUMN):
+ return dummy
- if not snippet:
- return
+ return None
- parent = self.model.get_iter(self.language_path)
- path = self.model.get_path(parent)
+ def unref_languages(self):
+ piter = self.model.get_iter_first()
+ library = Library()
- dummy = self.get_dummy(parent)
+ while piter:
+ if self.is_filled(piter):
+ language = self.get_language(self.model.get_path(piter))
+ library.save(language)
- if dummy:
- # Remove the dummy
- self.model.remove(dummy)
+ library.unref(language)
- # Add the snippet
- piter = self.add_snippet(parent, snippet.data)
- self.select_iter(piter)
+ piter = self.model.iter_next(piter)
- if not self.tree_view.row_expanded(path):
- self.tree_view.expand_row(path, False)
- self.select_iter(piter)
+ # Callbacks
+ def do_destroy(self):
+ Gtk.Dialog.do_destroy(self)
- self.tree_view.grab_focus()
+ if not self.model:
+ return
- path = self.model.get_path(piter)
- self.tree_view.set_cursor(path, self.column, True)
+ # Remove temporary drag export
+ if self._temp_export:
+ shutil.rmtree(os.path.dirname(self._temp_export))
+ self._temp_export = None
- def file_filter(self, name, pattern):
- fil = Gtk.FileFilter()
- fil.set_name(name)
+ self.unref_languages()
+ self.snippet = None
+ self.model = None
- for p in pattern:
- fil.add_pattern(p)
+ def on_cell_editing_started(self, renderer, editable, path):
+ piter = self.model.get_iter(path)
- return fil
+ if not self.model.iter_parent(piter):
+ renderer.stop_editing(True)
+ editable.remove_widget()
+ elif isinstance(editable, Gtk.Entry):
+ if self.snippet:
+ editable.set_text(self.snippet['description'])
+ else:
+ # This is the `Add a new snippet...` item
+ editable.set_text('')
- def import_snippets(self, files):
- success = True
+ editable.grab_focus()
- for gfile in files:
- if not gfile.has_uri_scheme('file'):
- continue
+ def on_cell_edited(self, cell, path, new_text):
+ if new_text != '':
+ piter = self.model.get_iter(path)
+ node = self.model.get_value(piter, self.SNIPPET_COLUMN)
- # Remove file://
- filename = gfile.get_path()
+ if node:
+ if node == self.snippet.data:
+ s = self.snippet
+ else:
+ s = Snippet(node)
- importer = Importer(filename)
- error = importer.run()
+ s['description'] = new_text
+ self.snippet_changed(piter)
+ self.select_iter(piter)
+ else:
+ # This is the `Add a new snippet...` item
+ # We create a new snippet
+ snippet = self.new_snippet({'description': new_text})
- if error:
- message = _('The following error occurred while importing: %s') % error
- success = False
- message_dialog(self.get_toplevel(), Gtk.MessageType.ERROR, message)
+ if snippet:
+ self.model.set_value(piter, self.SNIPPET_COLUMN, snippet.data)
+ self.snippet_changed(piter)
+ self.snippet = snippet
+ self.selection_changed()
- self.build_model(True)
+ def on_entry_accelerator_focus_out(self, entry, event):
+ if not self.snippet:
+ return
- if success:
- message = _('Import successfully completed')
- message_dialog(self.get_toplevel(), Gtk.MessageType.INFO, message)
+ entry.set_text(self.snippet.accelerator_display())
- def on_import_response(self, dialog, response):
- if response == Gtk.ResponseType.CANCEL or response == Gtk.ResponseType.CLOSE:
- dialog.destroy()
- return
+ def entry_tab_trigger_update_valid(self):
+ entry = self['entry_tab_trigger']
+ text = entry.get_text()
- f = dialog.get_files()
- dialog.destroy()
+ if text and not Library().valid_tab_trigger(text):
+ img = self['image_tab_trigger']
+ img.set_from_icon_name('dialog-error', Gtk.IconSize.BUTTON)
+ img.show()
- self.import_snippets(f)
+ #self['hbox_tab_trigger'].set_spacing(3)
+ tip = _('This is not a valid Tab trigger. Triggers can either contain alphanumeric characters
(or _, : and .) or a single (non-alphanumeric) character like: {, [, etc.')
- def on_import_snippets_button_clicked(self, button):
- dlg = Gtk.FileChooserDialog(parent=self.get_toplevel(), title=_("Import snippets"),
- action=Gtk.FileChooserAction.OPEN,
- buttons=(_("_Cancel"), Gtk.ResponseType.CANCEL,
- _("_Open"), Gtk.ResponseType.OK))
+ entry.set_tooltip_text(tip)
+ img.set_tooltip_text(tip)
+ else:
+ self['image_tab_trigger'].hide()
+ #self['hbox_tab_trigger'].set_spacing(0)
+ entry.set_tooltip_text(_('Single word the snippet is activated with after pressing Tab'))
- dlg.add_filter(self.file_filter(_('All supported archives'), ('*.gz','*.bz2','*.tar',
'*.xml')))
- dlg.add_filter(self.file_filter(_('Gzip compressed archive'), ('*.tar.gz',)))
- dlg.add_filter(self.file_filter(_('Bzip2 compressed archive'), ('*.tar.bz2',)))
- dlg.add_filter(self.file_filter(_('Single snippets file'), ('*.xml',)))
- dlg.add_filter(self.file_filter(_('All files'), '*'))
+ return False
- dlg.connect('response', self.on_import_response)
- dlg.set_local_only(True)
+ def on_entry_tab_trigger_focus_out(self, entry, event):
+ if not self.snippet:
+ return
- dlg.show()
+ text = entry.get_text()
- def export_snippets_real(self, filename, snippets, show_dialogs=True):
- export = Exporter(filename, snippets)
- error = export.run()
+ # save tag
+ self.snippet['tag'] = text
+ self.snippet_changed()
- if error:
- message = _('The following error occurred while exporting: %s') % error
- msgtype = Gtk.MessageType.ERROR
- retval = False
- else:
- message = _('Export successfully completed')
- msgtype = Gtk.MessageType.INFO
- retval = True
+ def on_entry_drop_targets_focus_out(self, entry, event):
+ if not self.snippet:
+ return
- if show_dialogs:
- message_dialog(self.get_toplevel(), msgtype, message)
+ text = entry.get_text()
- return retval
+ # save drop targets
+ self.snippet['drop-targets'] = text
+ self.snippet_changed()
- def on_export_response(self, dialog, response):
- filename = dialog.get_filename()
- snippets = dialog._export_snippets
+ def on_entry_tab_trigger_changed(self, entry):
+ self.entry_tab_trigger_update_valid()
- dialog.destroy()
+ def on_source_view_snippet_focus_out(self, source_view, event):
+ if not self.snippet:
+ return
- if response != Gtk.ResponseType.OK:
- return
+ buf = source_view.get_buffer()
+ text = buf.get_text(buf.get_start_iter(), \
+ buf.get_end_iter(), False)
- self.export_snippets_real(filename, snippets);
+ self.snippet['text'] = text
+ self.snippet_changed()
- def export_snippets(self, filename=None, show_dialogs=True):
- snippets = self.selected_snippets()
+ def on_add_snippet_button_clicked(self, button):
+ snippet = self.new_snippet()
- if not snippets or len(snippets) == 0:
- return False
+ if not snippet:
+ return
- usersnippets = []
- systemsnippets = []
+ parent = self.model.get_iter(self.language_path)
+ path = self.model.get_path(parent)
- # Iterate through snippets and look for system snippets
- for snippet in snippets:
- if snippet.can_modify():
- usersnippets.append(snippet)
- else:
- systemsnippets.append(snippet)
+ dummy = self.get_dummy(parent)
- export_snippets = snippets
+ if dummy:
+ # Remove the dummy
+ self.model.remove(dummy)
- if len(systemsnippets) != 0 and show_dialogs:
- # Ask if system snippets should also be exported
- message = _('Do you want to include selected <b>system</b> snippets in your export?')
- mes = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
- type=Gtk.MessageType.QUESTION,
- buttons=Gtk.ButtonsType.YES_NO,
- message_format=message)
- mes.set_property('use-markup', True)
- resp = mes.run()
- mes.destroy()
+ # Add the snippet
+ piter = self.add_snippet(parent, snippet.data)
+ self.select_iter(piter)
- if resp == Gtk.ResponseType.NO:
- export_snippets = usersnippets
- elif resp != Gtk.ResponseType.YES:
- return False
+ if not self.tree_view.row_expanded(path):
+ self.tree_view.expand_row(path, False)
+ self.select_iter(piter)
- if len(export_snippets) == 0 and show_dialogs:
- message = _('There are no snippets selected to be exported')
- message_dialog(self.get_toplevel(), Gtk.MessageType.QUESTION, message)
- return False
+ self.tree_view.grab_focus()
- if not filename:
- dlg = Gtk.FileChooserDialog(parent=self.get_toplevel(), title=_('Export snippets'),
- action=Gtk.FileChooserAction.SAVE,
- buttons=(_("_Cancel"), Gtk.ResponseType.CANCEL,
- _("_Save"), Gtk.ResponseType.OK))
+ path = self.model.get_path(piter)
+ self.tree_view.set_cursor(path, self.column, True)
- dlg._export_snippets = export_snippets
- dlg.add_filter(self.file_filter(_('All supported archives'),
('*.gz','*.bz2','*.tar')))
- dlg.add_filter(self.file_filter(_('Gzip compressed archive'), ('*.tar.gz',)))
- dlg.add_filter(self.file_filter(_('Bzip2 compressed archive'), ('*.tar.bz2',)))
+ def file_filter(self, name, pattern):
+ fil = Gtk.FileFilter()
+ fil.set_name(name)
- dlg.add_filter(self.file_filter(_('All files'), '*'))
- dlg.set_do_overwrite_confirmation(True)
- dlg.set_current_name(self.default_export_name)
+ for p in pattern:
+ fil.add_pattern(p)
- dlg.connect('response', self.on_export_response)
- dlg.set_local_only(True)
+ return fil
- dlg.show()
- return True
- else:
- return self.export_snippets_real(filename, export_snippets, show_dialogs)
+ def import_snippets(self, files):
+ success = True
- def on_export_snippets_button_clicked(self, button):
- snippets = self.selected_snippets()
+ for gfile in files:
+ if not gfile.has_uri_scheme('file'):
+ continue
- if not snippets or len(snippets) == 0:
- return
+ # Remove file://
+ filename = gfile.get_path()
- usersnippets = []
- systemsnippets = []
+ importer = Importer(filename)
+ error = importer.run()
- # Iterate through snippets and look for system snippets
- for snippet in snippets:
- if snippet.can_modify():
- usersnippets.append(snippet)
- else:
- systemsnippets.append(snippet)
+ if error:
+ message = _('The following error occurred while importing: %s') % error
+ success = False
+ helper.message_dialog(self.get_toplevel(), Gtk.MessageType.ERROR, message)
- dlg = Gtk.FileChooserDialog(parent=self.get_toplevel(), title=_('Export snippets'),
- action=Gtk.FileChooserAction.SAVE,
- buttons=(_('_Cancel'), Gtk.ResponseType.CANCEL,
- _('_Save'), Gtk.ResponseType.OK))
+ self.build_model(True)
- dlg._export_snippets = snippets
+ if success:
+ message = _('Import successfully completed')
+ helper.message_dialog(self.get_toplevel(), Gtk.MessageType.INFO, message)
- if len(systemsnippets) != 0:
- # Ask if system snippets should also be exported
- message = _('Do you want to include selected <b>system</b> snippets in your export?')
- mes = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
- type=Gtk.MessageType.QUESTION,
- buttons=Gtk.ButtonsType.YES_NO,
- message_format=message)
- mes.set_property('use-markup', True)
- resp = mes.run()
- mes.destroy()
+ def on_import_response(self, dialog, response):
+ if response == Gtk.ResponseType.CANCEL or response == Gtk.ResponseType.CLOSE:
+ dialog.destroy()
+ return
- if resp == Gtk.ResponseType.NO:
- dlg._export_snippets = usersnippets
- elif resp != Gtk.ResponseType.YES:
- dlg.destroy()
- return
+ f = dialog.get_files()
+ dialog.destroy()
- if len(dlg._export_snippets) == 0:
- dlg.destroy()
+ self.import_snippets(f)
- message = _('There are no snippets selected to be exported')
- message_dialog(self.get_toplevel(), Gtk.MessageType.QUESTION, message)
- return
+ def on_import_snippets_button_clicked(self, button):
+ dlg = Gtk.FileChooserDialog(parent=self.get_toplevel(), title=_("Import snippets"),
+ action=Gtk.FileChooserAction.OPEN,
+ buttons=(_("_Cancel"), Gtk.ResponseType.CANCEL,
+ _("_Open"), Gtk.ResponseType.OK))
- dlg.add_filter(self.file_filter(_('All supported archives'), ('*.gz','*.bz2','*.tar')))
- dlg.add_filter(self.file_filter(_('Gzip compressed archive'), ('*.tar.gz',)))
- dlg.add_filter(self.file_filter(_('Bzip2 compressed archive'), ('*.tar.bz2',)))
+ dlg.add_filter(self.file_filter(_('All supported archives'), ('*.gz','*.bz2','*.tar', '*.xml')))
+ dlg.add_filter(self.file_filter(_('Gzip compressed archive'), ('*.tar.gz',)))
+ dlg.add_filter(self.file_filter(_('Bzip2 compressed archive'), ('*.tar.bz2',)))
+ dlg.add_filter(self.file_filter(_('Single snippets file'), ('*.xml',)))
+ dlg.add_filter(self.file_filter(_('All files'), '*'))
- dlg.add_filter(self.file_filter(_('All files'), '*'))
- dlg.set_do_overwrite_confirmation(True)
- dlg.set_current_name(self.default_export_name)
+ dlg.connect('response', self.on_import_response)
+ dlg.set_local_only(True)
- dlg.connect('response', self.on_export_response)
- dlg.set_local_only(True)
+ dlg.show()
- dlg.show()
+ def export_snippets_real(self, filename, snippets, show_dialogs=True):
+ export = Exporter(filename, snippets)
+ error = export.run()
- def remove_snippet_revert(self, path, piter):
- node = self.snippet_from_iter(self.model, piter)
- Library().revert_snippet(node)
+ if error:
+ message = _('The following error occurred while exporting: %s') % error
+ msgtype = Gtk.MessageType.ERROR
+ retval = False
+ else:
+ message = _('Export successfully completed')
+ msgtype = Gtk.MessageType.INFO
+ retval = True
- return piter
+ if show_dialogs:
+ helper.message_dialog(self.get_toplevel(), msgtype, message)
- def remove_snippet_delete(self, path, piter):
- node = self.snippet_from_iter(self.model, piter)
- parent = self.model.iter_parent(piter)
+ return retval
- Library().remove_snippet(node)
- idx = path.get_indices()
+ def on_export_response(self, dialog, response):
+ filename = dialog.get_filename()
+ snippets = dialog._export_snippets
- if self.model.remove(piter):
- return piter
- elif idx[-1] != 0:
- self.select_iter(self.model.get_iter((idx[0], idx[1] - 1)))
- else:
- dummy = self.add_new_snippet_node(parent)
- self.tree_view.expand_row(self.model.get_path(parent), False)
- return dummy
+ dialog.destroy()
- def on_remove_snippet_button_clicked(self, button):
- override, remove, system = self.selected_snippets_state()
+ if response != Gtk.ResponseType.OK:
+ return
- if not (override ^ remove) or system:
- return
+ self.export_snippets_real(filename, snippets);
- paths = self.selected_snippets(include_languages=False, as_path=True)
+ def export_snippets(self, filename=None, show_dialogs=True):
+ snippets = self.selected_snippets()
- if override:
- action = self.remove_snippet_revert
- else:
- action = self.remove_snippet_delete
-
- # Remove selection
- self.tree_view.get_selection().unselect_all()
-
- # Create tree row references
- references = []
- for path in paths:
- # FIXME: this should be fixed in pygobject or something
- references.append(Gtk.TreeRowReference.new(self.model, path))
-
- # Remove/revert snippets
- select = None
- for reference in references:
- path = reference.get_path()
- piter = self.model.get_iter(path)
+ if not snippets or len(snippets) == 0:
+ return False
- res = action(path, piter)
+ usersnippets = []
+ systemsnippets = []
- if res:
- select = res
+ # Iterate through snippets and look for system snippets
+ for snippet in snippets:
+ if snippet.can_modify():
+ usersnippets.append(snippet)
+ else:
+ systemsnippets.append(snippet)
- if select:
- self.select_iter(select)
+ export_snippets = snippets
- self.selection_changed()
+ if len(systemsnippets) != 0 and show_dialogs:
+ # Ask if system snippets should also be exported
+ message = _('Do you want to include selected <b>system</b> snippets in your export?')
+ mes = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
+ type=Gtk.MessageType.QUESTION,
+ buttons=Gtk.ButtonsType.YES_NO,
+ message_format=message)
+ mes.set_property('use-markup', True)
+ resp = mes.run()
+ mes.destroy()
- def set_accelerator(self, keyval, mod):
- accelerator = Gtk.accelerator_name(keyval, mod)
- self.snippet['accelerator'] = accelerator
-
- return True
+ if resp == Gtk.ResponseType.NO:
+ export_snippets = usersnippets
+ elif resp != Gtk.ResponseType.YES:
+ return False
- def on_entry_accelerator_key_press(self, entry, event):
- source_view = self['source_view_snippet']
+ if len(export_snippets) == 0 and show_dialogs:
+ message = _('There are no snippets selected to be exported')
+ helper.message_dialog(self.get_toplevel(), Gtk.MessageType.QUESTION, message)
+ return False
+
+ if not filename:
+ dlg = Gtk.FileChooserDialog(parent=self.get_toplevel(), title=_('Export snippets'),
+ action=Gtk.FileChooserAction.SAVE,
+ buttons=(_("_Cancel"), Gtk.ResponseType.CANCEL,
+ _("_Save"), Gtk.ResponseType.OK))
+
+ dlg._export_snippets = export_snippets
+ dlg.add_filter(self.file_filter(_('All supported archives'), ('*.gz','*.bz2','*.tar')))
+ dlg.add_filter(self.file_filter(_('Gzip compressed archive'), ('*.tar.gz',)))
+ dlg.add_filter(self.file_filter(_('Bzip2 compressed archive'), ('*.tar.bz2',)))
+
+ dlg.add_filter(self.file_filter(_('All files'), '*'))
+ dlg.set_do_overwrite_confirmation(True)
+ dlg.set_current_name(self.default_export_name)
+
+ dlg.connect('response', self.on_export_response)
+ dlg.set_local_only(True)
+
+ dlg.show()
+ return True
+ else:
+ return self.export_snippets_real(filename, export_snippets, show_dialogs)
+
+ def on_export_snippets_button_clicked(self, button):
+ snippets = self.selected_snippets()
+
+ if not snippets or len(snippets) == 0:
+ return
+
+ usersnippets = []
+ systemsnippets = []
+
+ # Iterate through snippets and look for system snippets
+ for snippet in snippets:
+ if snippet.can_modify():
+ usersnippets.append(snippet)
+ else:
+ systemsnippets.append(snippet)
+
+ dlg = Gtk.FileChooserDialog(parent=self.get_toplevel(), title=_('Export snippets'),
+ action=Gtk.FileChooserAction.SAVE,
+ buttons=(_('_Cancel'), Gtk.ResponseType.CANCEL,
+ _('_Save'), Gtk.ResponseType.OK))
- if event.keyval == Gdk.keyval_from_name('Escape'):
- # Reset
- entry.set_text(self.snippet.accelerator_display())
- self.tree_view.grab_focus()
+ dlg._export_snippets = snippets
+
+ if len(systemsnippets) != 0:
+ # Ask if system snippets should also be exported
+ message = _('Do you want to include selected <b>system</b> snippets in your export?')
+ mes = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
+ type=Gtk.MessageType.QUESTION,
+ buttons=Gtk.ButtonsType.YES_NO,
+ message_format=message)
+ mes.set_property('use-markup', True)
+ resp = mes.run()
+ mes.destroy()
- return True
- elif event.keyval == Gdk.keyval_from_name('Delete') or \
- event.keyval == Gdk.keyval_from_name('BackSpace'):
- # Remove the accelerator
- entry.set_text('')
- self.snippet['accelerator'] = ''
- self.tree_view.grab_focus()
+ if resp == Gtk.ResponseType.NO:
+ dlg._export_snippets = usersnippets
+ elif resp != Gtk.ResponseType.YES:
+ dlg.destroy()
+ return
+
+ if len(dlg._export_snippets) == 0:
+ dlg.destroy()
+
+ message = _('There are no snippets selected to be exported')
+ helper.message_dialog(self.get_toplevel(), Gtk.MessageType.QUESTION, message)
+ return
+
+ dlg.add_filter(self.file_filter(_('All supported archives'), ('*.gz','*.bz2','*.tar')))
+ dlg.add_filter(self.file_filter(_('Gzip compressed archive'), ('*.tar.gz',)))
+ dlg.add_filter(self.file_filter(_('Bzip2 compressed archive'), ('*.tar.bz2',)))
+
+ dlg.add_filter(self.file_filter(_('All files'), '*'))
+ dlg.set_do_overwrite_confirmation(True)
+ dlg.set_current_name(self.default_export_name)
+
+ dlg.connect('response', self.on_export_response)
+ dlg.set_local_only(True)
+
+ dlg.show()
+
+ def remove_snippet_revert(self, path, piter):
+ node = self.snippet_from_iter(self.model, piter)
+ Library().revert_snippet(node)
+
+ return piter
+
+ def remove_snippet_delete(self, path, piter):
+ node = self.snippet_from_iter(self.model, piter)
+ parent = self.model.iter_parent(piter)
+
+ Library().remove_snippet(node)
+ idx = path.get_indices()
+
+ if self.model.remove(piter):
+ return piter
+ elif idx[-1] != 0:
+ self.select_iter(self.model.get_iter((idx[0], idx[1] - 1)))
+ else:
+ dummy = self.add_new_snippet_node(parent)
+ self.tree_view.expand_row(self.model.get_path(parent), False)
+ return dummy
+
+ def on_remove_snippet_button_clicked(self, button):
+ override, remove, system = self.selected_snippets_state()
+
+ if not (override ^ remove) or system:
+ return
+
+ paths = self.selected_snippets(include_languages=False, as_path=True)
+
+ if override:
+ action = self.remove_snippet_revert
+ else:
+ action = self.remove_snippet_delete
+
+ # Remove selection
+ self.tree_view.get_selection().unselect_all()
+
+ # Create tree row references
+ references = []
+ for path in paths:
+ # FIXME: this should be fixed in pygobject or something
+ references.append(Gtk.TreeRowReference.new(self.model, path))
+
+ # Remove/revert snippets
+ select = None
+ for reference in references:
+ path = reference.get_path()
+ piter = self.model.get_iter(path)
+
+ res = action(path, piter)
+
+ if res:
+ select = res
+
+ if select:
+ self.select_iter(select)
+
+ self.selection_changed()
+
+ def set_accelerator(self, keyval, mod):
+ accelerator = Gtk.accelerator_name(keyval, mod)
+ self.snippet['accelerator'] = accelerator
+
+ return True
+
+ def on_entry_accelerator_key_press(self, entry, event):
+ if event.keyval == Gdk.keyval_from_name('Escape'):
+ # Reset
+ entry.set_text(self.snippet.accelerator_display())
+ self.tree_view.grab_focus()
- self.snippet_changed()
- return True
- elif Library().valid_accelerator(event.keyval, event.get_state()):
- # New accelerator
- self.set_accelerator(event.keyval, \
- event.get_state() & Gtk.accelerator_get_default_mod_mask())
- entry.set_text(self.snippet.accelerator_display())
- self.snippet_changed()
- self.tree_view.grab_focus()
+ return True
+ elif event.keyval == Gdk.keyval_from_name('Delete') or \
+ event.keyval == Gdk.keyval_from_name('BackSpace'):
+ # Remove the accelerator
+ entry.set_text('')
+ self.snippet['accelerator'] = ''
+ self.tree_view.grab_focus()
- else:
- return True
+ self.snippet_changed()
+ return True
+ elif Library().valid_accelerator(event.keyval, event.get_state()):
+ # New accelerator
+ self.set_accelerator(event.keyval, \
+ event.get_state() & Gtk.accelerator_get_default_mod_mask())
+ entry.set_text(self.snippet.accelerator_display())
+ self.snippet_changed()
+ self.tree_view.grab_focus()
- def on_entry_accelerator_focus_in(self, entry, event):
- if self.snippet['accelerator']:
- entry.set_text(_('Type a new shortcut, or press Backspace to clear'))
- else:
- entry.set_text(_('Type a new shortcut'))
+ else:
+ return True
- def update_language_path(self):
- model, paths = self.tree_view.get_selection().get_selected_rows()
+ def on_entry_accelerator_focus_in(self, entry, event):
+ if self.snippet['accelerator']:
+ entry.set_text(_('Type a new shortcut, or press Backspace to clear'))
+ else:
+ entry.set_text(_('Type a new shortcut'))
- # Check if all have the same language parent
+ def update_language_path(self):
+ model, paths = self.tree_view.get_selection().get_selected_rows()
+
+ # Check if all have the same language parent
+ current_parent = None
+
+ for path in paths:
+ piter = model.get_iter(path)
+ parent = model.iter_parent(piter)
+
+ if parent:
+ path = model.get_path(parent)
+
+ if current_parent != None and current_parent != path:
current_parent = None
+ break
+ else:
+ current_parent = path
- for path in paths:
- piter = model.get_iter(path)
- parent = model.iter_parent(piter)
+ self.language_path = current_parent
- if parent:
- path = model.get_path(parent)
+ def on_tree_view_selection_changed(self, selection):
+ parent, piter, node = self.selected_snippet()
- if current_parent != None and current_parent != path:
- current_parent = None
- break
- else:
- current_parent = path
+ if self.snippet:
+ self.on_entry_tab_trigger_focus_out(self['entry_tab_trigger'],
+ None)
+ self.on_source_view_snippet_focus_out(self['source_view_snippet'],
+ None)
+ self.on_entry_drop_targets_focus_out(self['combo_drop_targets'].get_child(),
+ None)
- self.language_path = current_parent
+ self.update_language_path()
- def on_tree_view_selection_changed(self, selection):
- parent, piter, node = self.selected_snippet()
+ if node:
+ self.snippet = Snippet(node)
+ else:
+ self.snippet = None
- if self.snippet:
- self.on_entry_tab_trigger_focus_out(self['entry_tab_trigger'],
- None)
- self.on_source_view_snippet_focus_out(self['source_view_snippet'],
- None)
- self.on_entry_drop_targets_focus_out(self['combo_drop_targets'].get_child(),
- None)
+ self.selection_changed()
- self.update_language_path()
+ def iter_after(self, target, after):
+ if not after:
+ return True
- if node:
- self.snippet = Snippet(node)
- else:
- self.snippet = None
-
- self.selection_changed()
+ tp = self.model.get_path(target)
+ ap = self.model.get_path(after)
- def iter_after(self, target, after):
- if not after:
- return True
+ if tp[0] > ap[0] or (tp[0] == ap[0] and (len(ap) == 1 or tp[1] > ap[1])):
+ return True
- tp = self.model.get_path(target)
- ap = self.model.get_path(after)
+ return False
- if tp[0] > ap[0] or (tp[0] == ap[0] and (len(ap) == 1 or tp[1] > ap[1])):
- return True
+ def on_tree_view_snippets_key_press(self, treeview, event):
+ if event.keyval == Gdk.keyval_from_name('Delete'):
+ self.on_remove_snippet_button_clicked(None)
+ return True
- return False
+ def on_tree_view_snippets_row_expanded(self, treeview, piter, path):
+ # Check if it is already filled
+ self.fill_if_needed(piter)
+ self.select_iter(piter)
- def on_tree_view_snippets_key_press(self, treeview, event):
- if event.keyval == Gdk.keyval_from_name('Delete'):
- self.on_remove_snippet_button_clicked(None)
- return True
+ def on_entry_drop_targets_drag_data_received(self, entry, context, x, y, selection_data, info,
timestamp):
+ uris = helper.drop_get_uris(selection_data)
+ if not uris:
+ return
- def on_tree_view_snippets_row_expanded(self, treeview, piter, path):
- # Check if it is already filled
- self.fill_if_needed(piter)
- self.select_iter(piter)
+ text = entry.get_text()
- def on_entry_drop_targets_drag_data_received(self, entry, context, x, y, selection_data, info,
timestamp):
- uris = drop_get_uris(selection_data)
- if not uris:
- return
-
- text = entry.get_text()
-
- if text:
- mimes = [text]
- else:
- mimes = []
+ if text:
+ mimes = [text]
+ else:
+ mimes = []
- for uri in uris:
- try:
- mime = Gio.content_type_guess(uri)
- except:
- mime = None
+ for uri in uris:
+ try:
+ mime = Gio.content_type_guess(uri)
+ except:
+ mime = None
- if mime:
- mimes.append(mime)
+ if mime:
+ mimes.append(mime)
- entry.set_text(', '.join(mimes))
- self.on_entry_drop_targets_focus_out(entry, None)
- context.finish(True, False, timestamp)
+ entry.set_text(', '.join(mimes))
+ self.on_entry_drop_targets_focus_out(entry, None)
+ context.finish(True, False, timestamp)
- entry.stop_emission('drag_data_received')
+ entry.stop_emission('drag_data_received')
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/parser.py b/plugins/snippets/snippets/parser.py
index 628db4e..2b6043d 100644
--- a/plugins/snippets/snippets/parser.py
+++ b/plugins/snippets/snippets/parser.py
@@ -15,245 +15,242 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-import os
import re
-import sys
-from .substitutionparser import SubstitutionParser
class Token:
- def __init__(self, klass, data):
- self.klass = klass
- self.data = data
+ def __init__(self, klass, data):
+ self.klass = klass
+ self.data = data
- def __str__(self):
- return '%s: [%s]' % (self.klass, self.data)
+ def __str__(self):
+ return '%s: [%s]' % (self.klass, self.data)
- def __eq__(self, other):
- return self.klass == other.klass and self.data == other.data
+ def __eq__(self, other):
+ return self.klass == other.klass and self.data == other.data
- def __ne__(self, other):
- return not self.__eq__(other)
+ def __ne__(self, other):
+ return not self.__eq__(other)
class Parser:
- SREG_ENV = '[A-Z_]+'
- SREG_ID = '[0-9]+'
+ SREG_ENV = '[A-Z_]+'
+ SREG_ID = '[0-9]+'
- REG_ESCAPE = re.compile('(\\$(%s|\\(|\\{|<|%s)|`|\\\\)' % (SREG_ENV, SREG_ID))
+ REG_ESCAPE = re.compile('(\\$(%s|\\(|\\{|<|%s)|`|\\\\)' % (SREG_ENV, SREG_ID))
- def __init__(self, **kwargs):
- for k, v in kwargs.items():
- setattr(self, k, v)
+ def __init__(self, **kwargs):
+ for k, v in kwargs.items():
+ setattr(self, k, v)
- self.position = 0
- self.data_length = len(self.data)
+ self.position = 0
+ self.data_length = len(self.data)
- self.RULES = (self._match_env, self._match_regex, self._match_placeholder,
self._match_shell, self._match_eval, self._text)
+ self.RULES = (self._match_env, self._match_regex, self._match_placeholder, self._match_shell,
self._match_eval, self._text)
- def remains(self):
- return self.data[self.position:]
+ def remains(self):
+ return self.data[self.position:]
- def next_char(self):
- if self.position + 1 >= self.data_length:
- return ''
- else:
- return self.data[self.position + 1]
+ def next_char(self):
+ if self.position + 1 >= self.data_length:
+ return ''
+ else:
+ return self.data[self.position + 1]
- def char(self):
- if self.position >= self.data_length:
- return ''
- else:
- return self.data[self.position]
+ def char(self):
+ if self.position >= self.data_length:
+ return ''
+ else:
+ return self.data[self.position]
- def token(self):
- self.tktext = ''
+ def token(self):
+ self.tktext = ''
- while self.position < self.data_length:
- try:
- # Get first character
- func = {'$': self._rule,
- '`': self._try_match_shell}[self.char()]
- except:
- func = self._text
+ while self.position < self.data_length:
+ try:
+ # Get first character
+ func = {'$': self._rule,
+ '`': self._try_match_shell}[self.char()]
+ except:
+ func = self._text
- # Detect end of text token
- if func != self._text and self.tktext != '':
- return Token('text', self.tktext)
+ # Detect end of text token
+ if func != self._text and self.tktext != '':
+ return Token('text', self.tktext)
- tk = func()
+ tk = func()
- if tk:
- return tk
+ if tk:
+ return tk
- if self.tktext != '':
- return Token('text', self.tktext)
+ if self.tktext != '':
+ return Token('text', self.tktext)
- def _need_escape(self):
- text = self.remains()[1:]
+ def _need_escape(self):
+ text = self.remains()[1:]
- if text == '':
- return False
+ if text == '':
+ return False
- return self.REG_ESCAPE.match(text)
+ return self.REG_ESCAPE.match(text)
- def _escape(self):
- if not self._need_escape():
- return
+ def _escape(self):
+ if not self._need_escape():
+ return
- # Increase position with 1
- self.position += 1
+ # Increase position with 1
+ self.position += 1
- def _text(self):
- if self.char() == '\\':
- self._escape()
+ def _text(self):
+ if self.char() == '\\':
+ self._escape()
- self.tktext += self.char()
- self.position += 1
+ self.tktext += self.char()
+ self.position += 1
- def _rule(self):
- for rule in self.RULES:
- res = rule()
+ def _rule(self):
+ for rule in self.RULES:
+ res = rule()
- if res:
- return res
+ if res:
+ return res
- def _match_env(self):
- text = self.remains()
- match = re.match('\\$(%s)' % self.SREG_ENV, text) or re.match('\\${(%s)}' % self.SREG_ENV,
text)
+ def _match_env(self):
+ text = self.remains()
+ match = re.match('\\$(%s)' % self.SREG_ENV, text) or re.match('\\${(%s)}' % self.SREG_ENV, text)
- if match:
- self.position += len(match.group(0))
- return Token('environment', match.group(1))
+ if match:
+ self.position += len(match.group(0))
+ return Token('environment', match.group(1))
- def _parse_list(self, lst):
- pos = 0
- length = len(lst)
- items = []
- last = None
+ def _parse_list(self, lst):
+ pos = 0
+ length = len(lst)
+ items = []
+ last = None
- while pos < length:
- char = lst[pos]
- next = pos < length - 1 and lst[pos + 1]
+ while pos < length:
+ char = lst[pos]
+ next = pos < length - 1 and lst[pos + 1]
- if char == '\\' and (next == ',' or next == ']'):
- char = next
- pos += 1
- elif char == ',':
- if last != None:
- items.append(last)
+ if char == '\\' and (next == ',' or next == ']'):
+ char = next
+ pos += 1
+ elif char == ',':
+ if last != None:
+ items.append(last)
- last = None
- pos += 1
- continue
+ last = None
+ pos += 1
+ continue
- last = (last != None and last + char) or char
- pos += 1
+ last = (last != None and last + char) or char
+ pos += 1
- if last != None:
- items.append(last)
+ if last != None:
+ items.append(last)
- return items
+ return items
- def _parse_default(self, default):
- match = re.match('^\\s*(\\\\)?(\\[((\\\\]|[^\\]])+)\\]\\s*)$', default)
+ def _parse_default(self, default):
+ match = re.match('^\\s*(\\\\)?(\\[((\\\\]|[^\\]])+)\\]\\s*)$', default)
- if not match:
- return [default]
+ if not match:
+ return [default]
- groups = match.groups()
+ groups = match.groups()
- if groups[0]:
- return [groups[1]]
+ if groups[0]:
+ return [groups[1]]
- return self._parse_list(groups[2])
+ return self._parse_list(groups[2])
- def _match_placeholder(self):
- text = self.remains()
+ def _match_placeholder(self):
+ text = self.remains()
- match = re.match('\\${(%s)(:((\\\\\\}|[^}])+))?}' % self.SREG_ID, text) or
re.match('\\$(%s)' % self.SREG_ID, text)
+ match = re.match('\\${(%s)(:((\\\\\\}|[^}])+))?}' % self.SREG_ID, text) or re.match('\\$(%s)' %
self.SREG_ID, text)
- if not match:
- return None
+ if not match:
+ return None
- groups = match.groups()
- default = ''
- tabstop = int(groups[0])
- self.position += len(match.group(0))
+ groups = match.groups()
+ default = ''
+ tabstop = int(groups[0])
+ self.position += len(match.group(0))
- if len(groups) > 1 and groups[2]:
- default = self._parse_default(groups[2].replace('\\}', '}'))
+ if len(groups) > 1 and groups[2]:
+ default = self._parse_default(groups[2].replace('\\}', '}'))
- return Token('placeholder', {'tabstop': tabstop, 'default': default})
+ return Token('placeholder', {'tabstop': tabstop, 'default': default})
- def _match_shell(self):
- text = self.remains()
- match = re.match('`((%s):)?((\\\\`|[^`])+?)`' % self.SREG_ID, text) or
re.match('\\$\\(((%s):)?((\\\\\\)|[^\\)])+?)\\)' % self.SREG_ID, text)
+ def _match_shell(self):
+ text = self.remains()
+ match = re.match('`((%s):)?((\\\\`|[^`])+?)`' % self.SREG_ID, text) or
re.match('\\$\\(((%s):)?((\\\\\\)|[^\\)])+?)\\)' % self.SREG_ID, text)
- if not match:
- return None
+ if not match:
+ return None
- groups = match.groups()
- tabstop = (groups[1] and int(groups[1])) or -1
- self.position += len(match.group(0))
+ groups = match.groups()
+ tabstop = (groups[1] and int(groups[1])) or -1
+ self.position += len(match.group(0))
- if text[0] == '`':
- contents = groups[2].replace('\\`', '`')
- else:
- contents = groups[2].replace('\\)', ')')
+ if text[0] == '`':
+ contents = groups[2].replace('\\`', '`')
+ else:
+ contents = groups[2].replace('\\)', ')')
- return Token('shell', {'tabstop': tabstop, 'contents': contents})
+ return Token('shell', {'tabstop': tabstop, 'contents': contents})
- def _try_match_shell(self):
- return self._match_shell() or self._text()
+ def _try_match_shell(self):
+ return self._match_shell() or self._text()
- def _eval_options(self, options):
- reg = re.compile(self.SREG_ID)
- tabstop = -1
- depend = []
+ def _eval_options(self, options):
+ reg = re.compile(self.SREG_ID)
+ tabstop = -1
+ depend = []
- options = options.split(':')
+ options = options.split(':')
- for opt in options:
- if reg.match(opt):
- tabstop = int(opt)
- else:
- depend += self._parse_list(opt[1:-1])
+ for opt in options:
+ if reg.match(opt):
+ tabstop = int(opt)
+ else:
+ depend += self._parse_list(opt[1:-1])
- return (tabstop, depend)
+ return (tabstop, depend)
- def _match_eval(self):
- text = self.remains()
+ def _match_eval(self):
+ text = self.remains()
- options = '((%s)|\\[([0-9, ]+)\\])' % self.SREG_ID
- match = re.match('\\$<((%s:)*)((\\\\>|[^>])+?)>' % options, text)
+ options = '((%s)|\\[([0-9, ]+)\\])' % self.SREG_ID
+ match = re.match('\\$<((%s:)*)((\\\\>|[^>])+?)>' % options, text)
- if not match:
- return None
+ if not match:
+ return None
- groups = match.groups()
- (tabstop, depend) = (groups[0] and self._eval_options(groups[0][:-1])) or (-1, [])
- self.position += len(match.group(0))
+ groups = match.groups()
+ (tabstop, depend) = (groups[0] and self._eval_options(groups[0][:-1])) or (-1, [])
+ self.position += len(match.group(0))
- return Token('eval', {'tabstop': tabstop, 'dependencies': depend, 'contents':
groups[5].replace('\\>', '>')})
+ return Token('eval', {'tabstop': tabstop, 'dependencies': depend, 'contents':
groups[5].replace('\\>', '>')})
- def _match_regex(self):
- text = self.remains()
+ def _match_regex(self):
+ text = self.remains()
- content = '((?:\\\\[/]|\\\\}|[^/}])+)'
- match = re.match('\\${(?:(%s):)?\\s*(%s|\\$([A-Z_]+))?[/]%s[/]%s(?:[/]([a-zA-Z]*))?}' %
(self.SREG_ID, self.SREG_ID, content, content), text)
+ content = '((?:\\\\[/]|\\\\}|[^/}])+)'
+ match = re.match('\\${(?:(%s):)?\\s*(%s|\\$([A-Z_]+))?[/]%s[/]%s(?:[/]([a-zA-Z]*))?}' %
(self.SREG_ID, self.SREG_ID, content, content), text)
- if not match:
- return None
+ if not match:
+ return None
- groups = match.groups()
- tabstop = (groups[0] and int(groups[0])) or -1
- inp = (groups[2] or (groups[1] and int(groups[1]))) or ''
+ groups = match.groups()
+ tabstop = (groups[0] and int(groups[0])) or -1
+ inp = (groups[2] or (groups[1] and int(groups[1]))) or ''
- pattern = re.sub('\\\\([/}])', '\\1', groups[3])
- substitution = re.sub('\\\\([/}])', '\\1', groups[4])
- modifiers = groups[5] or ''
+ pattern = re.sub('\\\\([/}])', '\\1', groups[3])
+ substitution = re.sub('\\\\([/}])', '\\1', groups[4])
+ modifiers = groups[5] or ''
- self.position += len(match.group(0))
+ self.position += len(match.group(0))
- return Token('regex', {'tabstop': tabstop, 'input': inp, 'pattern': pattern, 'substitution':
substitution, 'modifiers': modifiers})
+ return Token('regex', {'tabstop': tabstop, 'input': inp, 'pattern': pattern, 'substitution':
substitution, 'modifiers': modifiers})
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/placeholder.py b/plugins/snippets/snippets/placeholder.py
index 3693e87..9758ba1 100644
--- a/plugins/snippets/snippets/placeholder.py
+++ b/plugins/snippets/snippets/placeholder.py
@@ -17,694 +17,690 @@
import traceback
import re
-import os
import sys
import signal
-import select
import locale
import subprocess
-from gi.repository import GObject
+from gi.repository import GObject, Gtk
-from .helper import *
+from . import helper
from .substitutionparser import SubstitutionParser
# These are places in a view where the cursor can go and do things
class Placeholder:
- def __init__(self, view, tabstop, environ, defaults, begin):
- self.ok = True
- self.done = False
- self.buf = view.get_buffer()
- self.view = view
- self.has_references = False
- self.mirrors = []
- self.leave_mirrors = []
- self.tabstop = tabstop
- self.environ = environ
- self.set_default(defaults)
- self.prev_contents = self.default
- self.set_mark_gravity()
+ def __init__(self, view, tabstop, environ, defaults, begin):
+ self.ok = True
+ self.done = False
+ self.buf = view.get_buffer()
+ self.view = view
+ self.has_references = False
+ self.mirrors = []
+ self.leave_mirrors = []
+ self.tabstop = tabstop
+ self.environ = environ
+ self.set_default(defaults)
+ self.prev_contents = self.default
+ self.set_mark_gravity()
- if begin:
- self.begin = self.buf.create_mark(None, begin, self.mark_gravity[0])
- else:
- self.begin = None
+ if begin:
+ self.begin = self.buf.create_mark(None, begin, self.mark_gravity[0])
+ else:
+ self.begin = None
- self.end = None
+ self.end = None
- def get_environ(self):
- return self.environ['utf8']
+ def get_environ(self):
+ return self.environ['utf8']
- def __str__(self):
- return '%s (%s)' % (str(self.__class__), str(self.default))
+ def __str__(self):
+ return '%s (%s)' % (str(self.__class__), str(self.default))
- def set_mark_gravity(self):
- self.mark_gravity = [True, False]
+ def set_mark_gravity(self):
+ self.mark_gravity = [True, False]
- def set_default(self, defaults):
- self.default = None
- self.defaults = []
+ def set_default(self, defaults):
+ self.default = None
+ self.defaults = []
- if not defaults:
- return
+ if not defaults:
+ return
- for d in defaults:
- dm = self.expand_environment(d)
-
- if dm:
- self.defaults.append(dm)
+ for d in defaults:
+ dm = self.expand_environment(d)
- if not self.default:
- self.default = dm
+ if dm:
+ self.defaults.append(dm)
- if dm != d:
- break
+ if not self.default:
+ self.default = dm
+
+ if dm != d:
+ break
- def literal(self, s):
- return repr(s)
+ def literal(self, s):
+ return repr(s)
- def format_environment(self, s):
- return s
+ def format_environment(self, s):
+ return s
- def re_environment(self, m):
- env = self.get_environ()
+ def re_environment(self, m):
+ env = self.get_environ()
- if m.group(1) or not m.group(2) in env:
- return '$' + m.group(2)
- else:
- return self.format_environment(env[m.group(2)])
+ if m.group(1) or not m.group(2) in env:
+ return '$' + m.group(2)
+ else:
+ return self.format_environment(env[m.group(2)])
- def expand_environment(self, text):
- if not text:
- return text
+ def expand_environment(self, text):
+ if not text:
+ return text
- return re.sub('(\\\\)?\\$([A-Z_]+)', self.re_environment, text)
+ return re.sub('(\\\\)?\\$([A-Z_]+)', self.re_environment, text)
- def get_iter(self, mark):
- if mark and not mark.get_deleted():
- return self.buf.get_iter_at_mark(mark)
- else:
- return None
+ def get_iter(self, mark):
+ if mark and not mark.get_deleted():
+ return self.buf.get_iter_at_mark(mark)
+ else:
+ return None
- def begin_iter(self):
- return self.get_iter(self.begin)
+ def begin_iter(self):
+ return self.get_iter(self.begin)
- def end_iter(self):
- return self.get_iter(self.end)
+ def end_iter(self):
+ return self.get_iter(self.end)
- def run_last(self, placeholders):
- begin = self.begin_iter()
- self.end = self.buf.create_mark(None, begin, self.mark_gravity[1])
+ def run_last(self, placeholders):
+ begin = self.begin_iter()
+ self.end = self.buf.create_mark(None, begin, self.mark_gravity[1])
- if self.default:
- insert_with_indent(self.view, begin, self.default, False, self)
+ if self.default:
+ helper.insert_with_indent(self.view, begin, self.default, False, self)
- def remove(self, force = False):
- if self.begin and not self.begin.get_deleted():
- self.buf.delete_mark(self.begin)
+ def remove(self, force = False):
+ if self.begin and not self.begin.get_deleted():
+ self.buf.delete_mark(self.begin)
- if self.end and not self.end.get_deleted():
- self.buf.delete_mark(self.end)
+ if self.end and not self.end.get_deleted():
+ self.buf.delete_mark(self.end)
- # Do something on beginning this placeholder
- def enter(self):
- if not self.begin or self.begin.get_deleted():
- return
+ # Do something on beginning this placeholder
+ def enter(self):
+ if not self.begin or self.begin.get_deleted():
+ return
- self.buf.move_mark(self.buf.get_insert(), self.begin_iter())
+ self.buf.move_mark(self.buf.get_insert(), self.begin_iter())
- if self.end:
- self.buf.move_mark(self.buf.get_selection_bound(), self.end_iter())
- else:
- self.buf.move_mark(self.buf.get_selection_bound(), self.begin_iter())
+ if self.end:
+ self.buf.move_mark(self.buf.get_selection_bound(), self.end_iter())
+ else:
+ self.buf.move_mark(self.buf.get_selection_bound(), self.begin_iter())
- def get_text(self):
- if self.begin and self.end:
- biter = self.begin_iter()
- eiter = self.end_iter()
+ def get_text(self):
+ if self.begin and self.end:
+ biter = self.begin_iter()
+ eiter = self.end_iter()
- if biter and eiter:
- return self.buf.get_text(self.begin_iter(), self.end_iter(), False)
- else:
- return ''
- else:
- return ''
+ if biter and eiter:
+ return self.buf.get_text(self.begin_iter(), self.end_iter(), False)
+ else:
+ return ''
+ else:
+ return ''
- def add_mirror(self, mirror, onleave = False):
- mirror.has_references = True
+ def add_mirror(self, mirror, onleave = False):
+ mirror.has_references = True
- if onleave:
- self.leave_mirrors.append(mirror)
- else:
- self.mirrors.append(mirror)
+ if onleave:
+ self.leave_mirrors.append(mirror)
+ else:
+ self.mirrors.append(mirror)
- def set_text(self, text):
- if self.begin.get_deleted() or self.end.get_deleted():
- return
+ def set_text(self, text):
+ if self.begin.get_deleted() or self.end.get_deleted():
+ return
- # Set from self.begin to self.end to text!
- self.buf.begin_user_action()
- # Remove everything between self.begin and self.end
- begin = self.begin_iter()
- self.buf.delete(begin, self.end_iter())
+ # Set from self.begin to self.end to text!
+ self.buf.begin_user_action()
+ # Remove everything between self.begin and self.end
+ begin = self.begin_iter()
+ self.buf.delete(begin, self.end_iter())
- # Insert the text from the mirror
- insert_with_indent(self.view, begin, text, True, self)
- self.buf.end_user_action()
+ # Insert the text from the mirror
+ helper.insert_with_indent(self.view, begin, text, True, self)
+ self.buf.end_user_action()
- self.update_contents()
+ self.update_contents()
- def update_contents(self):
- prev = self.prev_contents
- self.prev_contents = self.get_text()
+ def update_contents(self):
+ prev = self.prev_contents
+ self.prev_contents = self.get_text()
- if prev != self.get_text():
- for mirror in self.mirrors:
- if not mirror.update(self):
- return
+ if prev != self.get_text():
+ for mirror in self.mirrors:
+ if not mirror.update(self):
+ return
- def update_leave_mirrors(self):
- # Notify mirrors
- for mirror in self.leave_mirrors:
- if not mirror.update(self):
- return
+ def update_leave_mirrors(self):
+ # Notify mirrors
+ for mirror in self.leave_mirrors:
+ if not mirror.update(self):
+ return
- # Do something on ending this placeholder
- def leave(self):
- self.update_leave_mirrors()
+ # Do something on ending this placeholder
+ def leave(self):
+ self.update_leave_mirrors()
- def find_mirrors(self, text, placeholders):
- mirrors = []
+ def find_mirrors(self, text, placeholders):
+ mirrors = []
- while (True):
- m = re.search('(\\\\)?\\$(?:{([0-9]+)}|([0-9]+))', text)
+ while (True):
+ m = re.search('(\\\\)?\\$(?:{([0-9]+)}|([0-9]+))', text)
- if not m:
- break
+ if not m:
+ break
- # Skip escaped mirrors
- if m.group(1):
- text = text[m.end():]
- continue
+ # Skip escaped mirrors
+ if m.group(1):
+ text = text[m.end():]
+ continue
- tabstop = int(m.group(2) or m.group(3))
+ tabstop = int(m.group(2) or m.group(3))
- if tabstop in placeholders:
- if not tabstop in mirrors:
- mirrors.append(tabstop)
+ if tabstop in placeholders:
+ if not tabstop in mirrors:
+ mirrors.append(tabstop)
- text = text[m.end():]
- else:
- self.ok = False
- return None
+ text = text[m.end():]
+ else:
+ self.ok = False
+ return None
- return mirrors
+ return mirrors
# This is an placeholder which inserts a mirror of another Placeholder
class PlaceholderMirror(Placeholder):
- def __init__(self, view, tabstop, environ, begin):
- Placeholder.__init__(self, view, -1, environ, None, begin)
- self.mirror_stop = tabstop
+ def __init__(self, view, tabstop, environ, begin):
+ Placeholder.__init__(self, view, -1, environ, None, begin)
+ self.mirror_stop = tabstop
- def update(self, mirror):
- self.set_text(mirror.get_text())
- return True
+ def update(self, mirror):
+ self.set_text(mirror.get_text())
+ return True
- def run_last(self, placeholders):
- Placeholder.run_last(self, placeholders)
+ def run_last(self, placeholders):
+ Placeholder.run_last(self, placeholders)
- if self.mirror_stop in placeholders:
- mirror = placeholders[self.mirror_stop]
+ if self.mirror_stop in placeholders:
+ mirror = placeholders[self.mirror_stop]
- mirror.add_mirror(self)
+ mirror.add_mirror(self)
- if mirror.default:
- self.set_text(mirror.default)
- else:
- self.ok = False
+ if mirror.default:
+ self.set_text(mirror.default)
+ else:
+ self.ok = False
# This placeholder indicates the end of a snippet
class PlaceholderEnd(Placeholder):
- def __init__(self, view, environ, begin, default):
- Placeholder.__init__(self, view, 0, environ, default, begin)
+ def __init__(self, view, environ, begin, default):
+ Placeholder.__init__(self, view, 0, environ, default, begin)
- def run_last(self, placeholders):
- Placeholder.run_last(self, placeholders)
+ def run_last(self, placeholders):
+ Placeholder.run_last(self, placeholders)
- # Remove the begin mark and set the begin mark
- # to the end mark, this is needed so the end placeholder won't contain
- # any text
+ # Remove the begin mark and set the begin mark
+ # to the end mark, this is needed so the end placeholder won't contain
+ # any text
- if not self.default:
- self.mark_gravity[0] = False
- self.buf.delete_mark(self.begin)
- self.begin = self.buf.create_mark(None, self.end_iter(), self.mark_gravity[0])
+ if not self.default:
+ self.mark_gravity[0] = False
+ self.buf.delete_mark(self.begin)
+ self.begin = self.buf.create_mark(None, self.end_iter(), self.mark_gravity[0])
- def enter(self):
- if self.begin and not self.begin.get_deleted():
- self.buf.move_mark(self.buf.get_insert(), self.begin_iter())
+ def enter(self):
+ if self.begin and not self.begin.get_deleted():
+ self.buf.move_mark(self.buf.get_insert(), self.begin_iter())
- if self.end and not self.end.get_deleted():
- self.buf.move_mark(self.buf.get_selection_bound(), self.end_iter())
+ if self.end and not self.end.get_deleted():
+ self.buf.move_mark(self.buf.get_selection_bound(), self.end_iter())
- def leave(self):
- self.enter()
+ def leave(self):
+ self.enter()
# This placeholder is used to expand a command with embedded mirrors
class PlaceholderExpand(Placeholder):
- def __init__(self, view, tabstop, environ, begin, s):
- Placeholder.__init__(self, view, tabstop, environ, None, begin)
-
- self.mirror_text = {0: ''}
- self.timeout_id = None
- self.cmd = s
- self.instant_update = False
+ def __init__(self, view, tabstop, environ, begin, s):
+ Placeholder.__init__(self, view, tabstop, environ, None, begin)
- def __str__(self):
- s = Placeholder.__str__(self)
+ self.mirror_text = {0: ''}
+ self.timeout_id = None
+ self.cmd = s
+ self.instant_update = False
- return s + ' ' + self.cmd
+ def __str__(self):
+ s = Placeholder.__str__(self)
- def get_mirrors(self, placeholders):
- return self.find_mirrors(self.cmd, placeholders)
+ return s + ' ' + self.cmd
- # Check if all substitution placeholders are accounted for
- def run_last(self, placeholders):
- Placeholder.run_last(self, placeholders)
+ def get_mirrors(self, placeholders):
+ return self.find_mirrors(self.cmd, placeholders)
- self.ok = True
- mirrors = self.get_mirrors(placeholders)
+ # Check if all substitution placeholders are accounted for
+ def run_last(self, placeholders):
+ Placeholder.run_last(self, placeholders)
- if mirrors:
- allDefault = True
+ self.ok = True
+ mirrors = self.get_mirrors(placeholders)
- for mirror in mirrors:
- p = placeholders[mirror]
- p.add_mirror(self, not self.instant_update)
- self.mirror_text[p.tabstop] = p.default
+ if mirrors:
+ allDefault = True
- if not p.default and not isinstance(p, PlaceholderExpand):
- allDefault = False
+ for mirror in mirrors:
+ p = placeholders[mirror]
+ p.add_mirror(self, not self.instant_update)
+ self.mirror_text[p.tabstop] = p.default
- if allDefault:
- self.update(None)
- self.default = self.get_text() or None
- else:
- self.update(None)
- self.default = self.get_text() or None
+ if not p.default and not isinstance(p, PlaceholderExpand):
+ allDefault = False
- if self.tabstop == -1:
- self.done = True
+ if allDefault:
+ self.update(None)
+ self.default = self.get_text() or None
+ else:
+ self.update(None)
+ self.default = self.get_text() or None
- def re_placeholder(self, m, formatter):
- if m.group(1):
- return '"$' + m.group(2) + '"'
- else:
- if m.group(3):
- index = int(m.group(3))
- else:
- index = int(m.group(4))
+ if self.tabstop == -1:
+ self.done = True
- return formatter(self.mirror_text[index])
+ def re_placeholder(self, m, formatter):
+ if m.group(1):
+ return '"$' + m.group(2) + '"'
+ else:
+ if m.group(3):
+ index = int(m.group(3))
+ else:
+ index = int(m.group(4))
- def remove_timeout(self):
- if self.timeout_id != None:
- GObject.source_remove(self.timeout_id)
- self.timeout_id = None
+ return formatter(self.mirror_text[index])
- def install_timeout(self):
- self.remove_timeout()
- self.timeout_id = GObject.timeout_add(1000, self.timeout_cb)
+ def remove_timeout(self):
+ if self.timeout_id != None:
+ GObject.source_remove(self.timeout_id)
+ self.timeout_id = None
- def timeout_cb(self):
- self.timeout_id = None
+ def install_timeout(self):
+ self.remove_timeout()
+ self.timeout_id = GObject.timeout_add(1000, self.timeout_cb)
- return False
+ def timeout_cb(self):
+ self.timeout_id = None
- def format_environment(self, text):
- return self.literal(text)
+ return False
- def substitute(self, text, formatter = None):
- formatter = formatter or self.literal
+ def format_environment(self, text):
+ return self.literal(text)
- # substitute all mirrors, but also environmental variables
- text = re.sub('(\\\\)?\\$({([0-9]+)}|([0-9]+))', lambda m: self.re_placeholder(m, formatter),
- text)
+ def substitute(self, text, formatter = None):
+ formatter = formatter or self.literal
- return self.expand_environment(text)
+ # substitute all mirrors, but also environmental variables
+ text = re.sub('(\\\\)?\\$({([0-9]+)}|([0-9]+))', lambda m: self.re_placeholder(m, formatter),
+ text)
- def run_update(self):
- text = self.substitute(self.cmd)
+ return self.expand_environment(text)
- if text:
- ret = self.expand(text)
+ def run_update(self):
+ text = self.substitute(self.cmd)
- if ret:
- self.update_leave_mirrors()
- else:
- ret = True
+ if text:
+ ret = self.expand(text)
- return ret
+ if ret:
+ self.update_leave_mirrors()
+ else:
+ ret = True
- def update(self, mirror):
- text = None
+ return ret
- if mirror:
- self.mirror_text[mirror.tabstop] = mirror.get_text()
+ def update(self, mirror):
+ if mirror:
+ self.mirror_text[mirror.tabstop] = mirror.get_text()
- # Check if all substitutions have been made
- for tabstop in self.mirror_text:
- if tabstop == 0:
- continue
+ # Check if all substitutions have been made
+ for tabstop in self.mirror_text:
+ if tabstop == 0:
+ continue
- if self.mirror_text[tabstop] == None:
- return False
+ if self.mirror_text[tabstop] == None:
+ return False
- return self.run_update()
+ return self.run_update()
- def expand(self, text):
- return True
+ def expand(self, text):
+ return True
# The shell placeholder executes commands in a subshell
class PlaceholderShell(PlaceholderExpand):
- def __init__(self, view, tabstop, environ, begin, s):
- PlaceholderExpand.__init__(self, view, tabstop, environ, begin, s)
+ def __init__(self, view, tabstop, environ, begin, s):
+ PlaceholderExpand.__init__(self, view, tabstop, environ, begin, s)
- self.shell = None
- self.remove_me = False
+ self.shell = None
+ self.remove_me = False
- def get_environ(self):
- return self.environ['noenc']
+ def get_environ(self):
+ return self.environ['noenc']
- def close_shell(self):
- self.shell.stdout.close()
- self.shell = None
+ def close_shell(self):
+ self.shell.stdout.close()
+ self.shell = None
- def timeout_cb(self):
- PlaceholderExpand.timeout_cb(self)
- self.remove_timeout()
+ def timeout_cb(self):
+ PlaceholderExpand.timeout_cb(self)
+ self.remove_timeout()
- if not self.shell:
- return False
+ if not self.shell:
+ return False
- GObject.source_remove(self.watch_id)
- self.close_shell()
+ GObject.source_remove(self.watch_id)
+ self.close_shell()
- if self.remove_me:
- PlaceholderExpand.remove(self)
+ if self.remove_me:
+ PlaceholderExpand.remove(self)
- message_dialog(None, Gtk.MessageType.ERROR, 'Execution of the shell ' \
- 'command (%s) exceeded the maximum time; ' \
- 'execution aborted.' % self.command)
+ helper.message_dialog(None, Gtk.MessageType.ERROR, 'Execution of the shell ' \
+ 'command (%s) exceeded the maximum time; ' \
+ 'execution aborted.' % self.command)
- return False
+ return False
- def process_close(self):
- self.close_shell()
- self.remove_timeout()
+ def process_close(self):
+ self.close_shell()
+ self.remove_timeout()
- self.set_text(str.join('', self.shell_output).rstrip('\n'))
+ self.set_text(str.join('', self.shell_output).rstrip('\n'))
- if self.default == None:
- self.default = self.get_text()
- self.leave()
+ if self.default == None:
+ self.default = self.get_text()
+ self.leave()
- if self.remove_me:
- PlaceholderExpand.remove(self, True)
+ if self.remove_me:
+ PlaceholderExpand.remove(self, True)
- def process_cb(self, source, condition):
- if condition & GObject.IO_IN:
- line = source.readline()
+ def process_cb(self, source, condition):
+ if condition & GObject.IO_IN:
+ line = source.readline()
- if len(line) > 0:
- try:
- line = line.decode('utf-8')
- except UnicodeDecodeError:
- line = line.decode(locale.getdefaultlocale()[1], errors='replace')
+ if len(line) > 0:
+ try:
+ line = line.decode('utf-8')
+ except UnicodeDecodeError:
+ line = line.decode(locale.getdefaultlocale()[1], errors='replace')
- self.shell_output += line
- self.install_timeout()
+ self.shell_output += line
+ self.install_timeout()
- return True
+ return True
- self.process_close()
- return False
+ self.process_close()
+ return False
- def literal_replace(self, match):
- return "\\%s" % (match.group(0))
+ def literal_replace(self, match):
+ return "\\%s" % (match.group(0))
- def literal(self, text):
- return '"' + re.sub('([\\\\"])', self.literal_replace, text) + '"'
+ def literal(self, text):
+ return '"' + re.sub('([\\\\"])', self.literal_replace, text) + '"'
- def expand(self, text):
- self.remove_timeout()
+ def expand(self, text):
+ self.remove_timeout()
- if self.shell:
- GObject.source_remove(self.watch_id)
- self.close_shell()
-
- popen_args = {
- 'cwd': None,
- 'shell': True,
- 'env': self.get_environ(),
- 'stdout': subprocess.PIPE
- }
-
- self.command = text
- self.shell = subprocess.Popen(text, **popen_args)
- self.shell_output = ''
- self.watch_id = GObject.io_add_watch(self.shell.stdout, GObject.IO_IN | \
- GObject.IO_HUP, self.process_cb)
- self.install_timeout()
+ if self.shell:
+ GObject.source_remove(self.watch_id)
+ self.close_shell()
- return True
+ popen_args = {
+ 'cwd': None,
+ 'shell': True,
+ 'env': self.get_environ(),
+ 'stdout': subprocess.PIPE
+ }
+
+ self.command = text
+ self.shell = subprocess.Popen(text, **popen_args)
+ self.shell_output = ''
+ self.watch_id = GObject.io_add_watch(self.shell.stdout, GObject.IO_IN | \
+ GObject.IO_HUP, self.process_cb)
+ self.install_timeout()
- def remove(self, force = False):
- if not force and self.shell:
- # Still executing shell command
- self.remove_me = True
- else:
- if force:
- self.remove_timeout()
+ return True
- if self.shell:
- self.close_shell()
+ def remove(self, force = False):
+ if not force and self.shell:
+ # Still executing shell command
+ self.remove_me = True
+ else:
+ if force:
+ self.remove_timeout()
+
+ if self.shell:
+ self.close_shell()
- PlaceholderExpand.remove(self, force)
+ PlaceholderExpand.remove(self, force)
class TimeoutError(Exception):
- def __init__(self, value):
- self.value = value
+ def __init__(self, value):
+ self.value = value
- def __str__(self):
- return repr(self.value)
+ def __str__(self):
+ return repr(self.value)
# The python placeholder evaluates commands in python
class PlaceholderEval(PlaceholderExpand):
- def __init__(self, view, tabstop, environ, refs, begin, s, namespace):
- PlaceholderExpand.__init__(self, view, tabstop, environ, begin, s)
+ def __init__(self, view, tabstop, environ, refs, begin, s, namespace):
+ PlaceholderExpand.__init__(self, view, tabstop, environ, begin, s)
+
+ self.fdread = 0
+ self.remove_me = False
+ self.namespace = namespace
+
+ self.refs = []
- self.fdread = 0
- self.remove_me = False
- self.namespace = namespace
+ if refs:
+ for ref in refs:
+ self.refs.append(int(ref.strip()))
- self.refs = []
+ def get_mirrors(self, placeholders):
+ mirrors = PlaceholderExpand.get_mirrors(self, placeholders)
- if refs:
- for ref in refs:
- self.refs.append(int(ref.strip()))
+ if not self.ok:
+ return None
- def get_mirrors(self, placeholders):
- mirrors = PlaceholderExpand.get_mirrors(self, placeholders)
+ for ref in self.refs:
+ if ref in placeholders:
+ if ref not in mirrors:
+ mirrors.append(ref)
+ else:
+ self.ok = False
+ return None
- if not self.ok:
- return None
+ return mirrors
- for ref in self.refs:
- if ref in placeholders:
- if ref not in mirrors:
- mirrors.append(ref)
- else:
- self.ok = False
- return None
+ # SIGALRM is not supported on all platforms (e.g. windows). Timeout
+ # with SIGALRM will not be used on those platforms. This will
+ # potentially block gedit if you have a placeholder which gets stuck,
+ # but it's better than not supporting them at all. At some point we
+ # might have proper thread support and we can fix this in a better way
+ def timeout_supported(self):
+ return hasattr(signal, 'SIGALRM')
- return mirrors
+ def timeout_cb(self, signum = 0, frame = 0):
+ raise TimeoutError("Operation timed out (>2 seconds)")
- # SIGALRM is not supported on all platforms (e.g. windows). Timeout
- # with SIGALRM will not be used on those platforms. This will
- # potentially block gedit if you have a placeholder which gets stuck,
- # but it's better than not supporting them at all. At some point we
- # might have proper thread support and we can fix this in a better way
- def timeout_supported(self):
- return hasattr(signal, 'SIGALRM')
+ def install_timeout(self):
+ if not self.timeout_supported():
+ return
- def timeout_cb(self, signum = 0, frame = 0):
- raise TimeoutError("Operation timed out (>2 seconds)")
+ if self.timeout_id != None:
+ self.remove_timeout()
- def install_timeout(self):
- if not self.timeout_supported():
- return
+ self.timeout_id = signal.signal(signal.SIGALRM, self.timeout_cb)
+ signal.alarm(2)
- if self.timeout_id != None:
- self.remove_timeout()
+ def remove_timeout(self):
+ if not self.timeout_supported():
+ return
- self.timeout_id = signal.signal(signal.SIGALRM, self.timeout_cb)
- signal.alarm(2)
+ if self.timeout_id != None:
+ signal.alarm(0)
- def remove_timeout(self):
- if not self.timeout_supported():
- return
+ signal.signal(signal.SIGALRM, self.timeout_id)
- if self.timeout_id != None:
- signal.alarm(0)
+ self.timeout_id = None
- signal.signal(signal.SIGALRM, self.timeout_id)
+ def expand(self, text):
+ self.remove_timeout()
- self.timeout_id = None
+ text = text.strip()
+ self.command = text
- def expand(self, text):
+ if not self.command or self.command == '':
+ self.set_text('')
+ return
+
+ text = "def process_snippet():\n\t" + "\n\t".join(text.split("\n"))
+
+ if 'process_snippet' in self.namespace:
+ del self.namespace['process_snippet']
+
+ try:
+ exec(text, self.namespace)
+ except:
+ traceback.print_exc()
+
+ if 'process_snippet' in self.namespace:
+ try:
+ # Install a sigalarm signal. This is a HACK to make sure
+ # gedit doesn't get freezed by someone creating a python
+ # placeholder which for instance loops indefinately. Since
+ # the code is executed synchronously it will hang gedit. With
+ # the alarm signal we raise an exception and catch this
+ # (see below). We show an error message and return False.
+ # ___this is a HACK___ and should be fixed properly (I just
+ # don't know how)
+ self.install_timeout()
+ result = self.namespace['process_snippet']()
+ self.remove_timeout()
+ except TimeoutError:
self.remove_timeout()
- text = text.strip()
- self.command = text
+ helper.message_dialog(None, Gtk.MessageType.ERROR, \
+ _('Execution of the Python command (%s) exceeds the maximum ' \
+ 'time, execution aborted.') % self.command)
- if not self.command or self.command == '':
- self.set_text('')
- return
+ return False
+ except Exception as detail:
+ self.remove_timeout()
- text = "def process_snippet():\n\t" + "\n\t".join(text.split("\n"))
+ helper.message_dialog(None, Gtk.MessageType.ERROR,
+ _('Execution of the Python command (%s) failed: %s') %
+ (self.command, detail))
- if 'process_snippet' in self.namespace:
- del self.namespace['process_snippet']
+ return False
- try:
- exec(text, self.namespace)
- except:
- traceback.print_exc()
-
- if 'process_snippet' in self.namespace:
- try:
- # Install a sigalarm signal. This is a HACK to make sure
- # gedit doesn't get freezed by someone creating a python
- # placeholder which for instance loops indefinately. Since
- # the code is executed synchronously it will hang gedit. With
- # the alarm signal we raise an exception and catch this
- # (see below). We show an error message and return False.
- # ___this is a HACK___ and should be fixed properly (I just
- # don't know how)
- self.install_timeout()
- result = self.namespace['process_snippet']()
- self.remove_timeout()
- except TimeoutError:
- self.remove_timeout()
-
- message_dialog(None, Gtk.MessageType.ERROR, \
- _('Execution of the Python command (%s) exceeds the maximum ' \
- 'time, execution aborted.') % self.command)
-
- return False
- except Exception as detail:
- self.remove_timeout()
-
- message_dialog(None, Gtk.MessageType.ERROR,
- _('Execution of the Python command (%s) failed: %s') %
- (self.command, detail))
-
- return False
-
- if result == None:
- # sys.stderr.write("%s:\n>> %s\n" % (_('The following python code, run in a
snippet, does not return a value'), "\n>> ".join(self.command.split("\n"))))
- result = ''
-
- self.set_text(str(result))
+ if result == None:
+ # sys.stderr.write("%s:\n>> %s\n" % (_('The following python code, run in a snippet, does
not return a value'), "\n>> ".join(self.command.split("\n"))))
+ result = ''
- return True
+ self.set_text(str(result))
+
+ return True
# Regular expression placeholder
class PlaceholderRegex(PlaceholderExpand):
- def __init__(self, view, tabstop, environ, begin, inp, pattern, substitution, modifiers):
- PlaceholderExpand.__init__(self, view, tabstop, environ, begin, '')
+ def __init__(self, view, tabstop, environ, begin, inp, pattern, substitution, modifiers):
+ PlaceholderExpand.__init__(self, view, tabstop, environ, begin, '')
- self.instant_update = True
- self.inp = inp
- self.pattern = pattern
- self.substitution = substitution
+ self.instant_update = True
+ self.inp = inp
+ self.pattern = pattern
+ self.substitution = substitution
- self.init_modifiers(modifiers)
+ self.init_modifiers(modifiers)
- def init_modifiers(self, modifiers):
- mods = {'I': re.I,
- 'L': re.L,
- 'M': re.M,
- 'S': re.S,
- 'U': re.U,
- 'X': re.X}
+ def init_modifiers(self, modifiers):
+ mods = {'I': re.I,
+ 'L': re.L,
+ 'M': re.M,
+ 'S': re.S,
+ 'U': re.U,
+ 'X': re.X}
- self.modifiers = 0
+ self.modifiers = 0
- for modifier in modifiers:
- if modifier in mods:
- self.modifiers |= mods[modifier]
+ for modifier in modifiers:
+ if modifier in mods:
+ self.modifiers |= mods[modifier]
- def get_mirrors(self, placeholders):
- mirrors = self.find_mirrors(self.pattern, placeholders) +
self.find_mirrors(self.substitution, placeholders)
+ def get_mirrors(self, placeholders):
+ mirrors = self.find_mirrors(self.pattern, placeholders) + self.find_mirrors(self.substitution,
placeholders)
- if isinstance(self.inp, int):
- if self.inp not in placeholders:
- self.ok = False
- return None
- elif self.inp not in mirrors:
- mirrors.append(self.inp)
+ if isinstance(self.inp, int):
+ if self.inp not in placeholders:
+ self.ok = False
+ return None
+ elif self.inp not in mirrors:
+ mirrors.append(self.inp)
- return mirrors
+ return mirrors
- def literal(self, s):
- return re.escape(s)
+ def literal(self, s):
+ return re.escape(s)
- def get_input(self):
- env = self.get_environ()
+ def get_input(self):
+ env = self.get_environ()
- if isinstance(self.inp, int):
- return self.mirror_text[self.inp]
- elif self.inp in env:
- return env[self.inp]
- else:
- return ''
+ if isinstance(self.inp, int):
+ return self.mirror_text[self.inp]
+ elif self.inp in env:
+ return env[self.inp]
+ else:
+ return ''
- def run_update(self):
- pattern = self.substitute(self.pattern)
- substitution = self.substitute(self.substitution, SubstitutionParser.escape_substitution)
+ def run_update(self):
+ pattern = self.substitute(self.pattern)
+ substitution = self.substitute(self.substitution, SubstitutionParser.escape_substitution)
- if pattern:
- return self.expand(pattern, substitution)
+ if pattern:
+ return self.expand(pattern, substitution)
- return True
+ return True
- def expand(self, pattern, substitution):
- # Try to compile pattern
- try:
- regex = re.compile(pattern, self.modifiers)
- except re.error as message:
- sys.stderr.write('Could not compile regular expression: %s\n%s\n' % (pattern,
message))
- return False
+ def expand(self, pattern, substitution):
+ # Try to compile pattern
+ try:
+ regex = re.compile(pattern, self.modifiers)
+ except re.error as message:
+ sys.stderr.write('Could not compile regular expression: %s\n%s\n' % (pattern, message))
+ return False
- inp = self.get_input()
- match = regex.search(inp)
+ inp = self.get_input()
+ match = regex.search(inp)
- if not match:
- self.set_text(inp)
- else:
- groups = match.groupdict()
+ if not match:
+ self.set_text(inp)
+ else:
+ groups = match.groupdict()
- idx = 0
- for group in match.groups():
- groups[str(idx + 1)] = group
- idx += 1
+ idx = 0
+ for group in match.groups():
+ groups[str(idx + 1)] = group
+ idx += 1
- groups['0'] = match.group(0)
+ groups['0'] = match.group(0)
- parser = SubstitutionParser(substitution, groups)
- self.set_text(parser.parse())
+ parser = SubstitutionParser(substitution, groups)
+ self.set_text(parser.parse())
- return True
+ return True
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/shareddata.py b/plugins/snippets/snippets/shareddata.py
index f3268ac..be6fd14 100644
--- a/plugins/snippets/snippets/shareddata.py
+++ b/plugins/snippets/snippets/shareddata.py
@@ -20,6 +20,9 @@ import os
from gi.repository import Gtk
+# To register the GeditSnippetsManager type
+from .manager import Manager
+
class SharedData(object, metaclass=Singleton):
def __init__(self):
self.dlg = None
diff --git a/plugins/snippets/snippets/snippet.py b/plugins/snippets/snippets/snippet.py
index bd21470..6b18156 100644
--- a/plugins/snippets/snippets/snippet.py
+++ b/plugins/snippets/snippets/snippet.py
@@ -15,345 +15,346 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-import os
-from gi.repository import Gio
+from gi.repository import Gio, Gtk
-from .placeholder import *
-from .parser import Parser, Token
-from .helper import *
+import sys
+
+from .placeholder import PlaceholderEnd, PlaceholderMirror, Placeholder, PlaceholderShell, PlaceholderEval,
PlaceholderRegex, PlaceholderExpand
+from .parser import Parser
+from . import helper
class EvalUtilities:
- def __init__(self, view=None):
- self.view = view
- self._init_namespace()
+ def __init__(self, view=None):
+ self.view = view
+ self._init_namespace()
- def _init_namespace(self):
- self.namespace = {
- '__builtins__': __builtins__,
- 'align': self.util_align,
- 'readfile': self.util_readfile,
- 'filesize': self.util_filesize
- }
+ def _init_namespace(self):
+ self.namespace = {
+ '__builtins__': __builtins__,
+ 'align': self.util_align,
+ 'readfile': self.util_readfile,
+ 'filesize': self.util_filesize
+ }
- def _real_len(self, s, tablen = 0):
- if tablen == 0:
- tablen = self.view.get_tab_width()
+ def _real_len(self, s, tablen = 0):
+ if tablen == 0:
+ tablen = self.view.get_tab_width()
- return len(s.expandtabs(tablen))
+ return len(s.expandtabs(tablen))
- def _filename_to_uri(self, filename):
- gfile = Gio.file_new_for_path(filename)
+ def _filename_to_uri(self, filename):
+ gfile = Gio.file_new_for_path(filename)
- return gfile.get_uri()
+ return gfile.get_uri()
- def util_readfile(self, filename):
- stream = Gio.file_new_for_path(filename).read()
+ def util_readfile(self, filename):
+ stream = Gio.file_new_for_path(filename).read()
- if not stream:
- return ''
+ if not stream:
+ return ''
- res = stream.read()
- stream.close()
+ res = stream.read()
+ stream.close()
- return res
+ return res
- def util_filesize(self, filename):
- gfile = Gio.file_new_for_path(filename)
- info = gfile.query_info(Gio.FILE_ATTRIBUTE_STANDARD_SIZE)
+ def util_filesize(self, filename):
+ gfile = Gio.file_new_for_path(filename)
+ info = gfile.query_info(Gio.FILE_ATTRIBUTE_STANDARD_SIZE)
- if not info:
- return 0
+ if not info:
+ return 0
- return info.get_size()
+ return info.get_size()
- def util_align(self, items):
- maxlen = []
- tablen = self.view.get_tab_width()
+ def util_align(self, items):
+ maxlen = []
+ tablen = self.view.get_tab_width()
- for row in range(0, len(items)):
- for col in range(0, len(items[row]) - 1):
- if row == 0:
- maxlen.append(0)
+ for row in range(0, len(items)):
+ for col in range(0, len(items[row]) - 1):
+ if row == 0:
+ maxlen.append(0)
- items[row][col] += "\t"
- rl = self._real_len(items[row][col], tablen)
+ items[row][col] += "\t"
+ rl = self._real_len(items[row][col], tablen)
- if (rl > maxlen[col]):
- maxlen[col] = rl
+ if (rl > maxlen[col]):
+ maxlen[col] = rl
- result = ''
+ result = ''
- for row in range(0, len(items)):
- for col in range(0, len(items[row]) - 1):
- item = items[row][col]
+ for row in range(0, len(items)):
+ for col in range(0, len(items[row]) - 1):
+ item = items[row][col]
- result += item + ("\t" * int(((maxlen[col] - \
- self._real_len(item, tablen)) / tablen)))
+ result += item + ("\t" * int(((maxlen[col] - \
+ self._real_len(item, tablen)) / tablen)))
- result += items[row][len(items[row]) - 1]
+ result += items[row][len(items[row]) - 1]
- if row != len(items) - 1:
- result += "\n"
+ if row != len(items) - 1:
+ result += "\n"
- return result
+ return result
class Snippet:
- def __init__(self, data, environ = {}):
- self.data = data
- self.environ = environ
-
- def __getitem__(self, prop):
- return self.data[prop]
-
- def __setitem__(self, prop, value):
- self.data[prop] = value
-
- def accelerator_display(self):
- accel = self['accelerator']
-
- if accel:
- keyval, mod = Gtk.accelerator_parse(accel)
- accel = Gtk.accelerator_get_label(keyval, mod)
-
- return accel or ''
+ def __init__(self, data, environ = {}):
+ self.data = data
+ self.environ = environ
+
+ def __getitem__(self, prop):
+ return self.data[prop]
+
+ def __setitem__(self, prop, value):
+ self.data[prop] = value
+
+ def accelerator_display(self):
+ accel = self['accelerator']
+
+ if accel:
+ keyval, mod = Gtk.accelerator_parse(accel)
+ accel = Gtk.accelerator_get_label(keyval, mod)
+
+ return accel or ''
- def display(self):
- nm = markup_escape(self['description'])
-
- tag = self['tag']
- accel = self.accelerator_display()
- detail = []
-
- if tag and tag != '':
- detail.append(tag)
-
- if accel and accel != '':
- detail.append(accel)
-
- if not detail:
- return nm
- else:
- return nm + ' (<b>' + markup_escape(', '.join(detail)) + \
- '</b>)'
-
- def _add_placeholder(self, placeholder):
- if placeholder.tabstop in self.placeholders:
- if placeholder.tabstop == -1:
- self.placeholders[-1].append(placeholder)
- self.plugin_data.ordered_placeholders.append(placeholder)
- elif placeholder.tabstop == -1:
- self.placeholders[-1] = [placeholder]
- self.plugin_data.ordered_placeholders.append(placeholder)
- else:
- self.placeholders[placeholder.tabstop] = placeholder
- self.plugin_data.ordered_placeholders.append(placeholder)
-
- def _insert_text(self, text):
- # Insert text keeping indentation in mind
- indented = str.join('\n' + self._indent, spaces_instead_of_tabs(self._view,
text).split('\n'))
- self._view.get_buffer().insert(self._insert_iter(), indented)
-
- def _insert_iter(self):
- return self._view.get_buffer().get_iter_at_mark(self._insert_mark)
-
- def _create_environment(self, data):
- if data in self.environ['utf8']:
- val = self.environ['utf8'][data]
- else:
- val = ''
-
- # Get all the current indentation
- all_indent = compute_indentation(self._view, self._insert_iter())
-
- # Substract initial indentation to get the snippet indentation
- indent = all_indent[len(self._indent):]
-
- # Keep indentation
- return str.join('\n' + indent, val.split('\n'))
-
- def _create_placeholder(self, data):
- tabstop = data['tabstop']
- begin = self._insert_iter()
-
- if tabstop == 0:
- # End placeholder
- return PlaceholderEnd(self._view, self.environ, begin, data['default'])
- elif tabstop in self.placeholders:
- # Mirror placeholder
- return PlaceholderMirror(self._view, tabstop, self.environ, begin)
- else:
- # Default placeholder
- return Placeholder(self._view, tabstop, self.environ, data['default'], begin)
-
- def _create_shell(self, data):
- begin = self._insert_iter()
- return PlaceholderShell(self._view, data['tabstop'], self.environ, begin, data['contents'])
-
- def _create_eval(self, data):
- begin = self._insert_iter()
- return PlaceholderEval(self._view, data['tabstop'], self.environ, data['dependencies'],
begin, data['contents'], self._utils.namespace)
-
- def _create_regex(self, data):
- begin = self._insert_iter()
- return PlaceholderRegex(self._view, data['tabstop'], self.environ, begin, data['input'],
data['pattern'], data['substitution'], data['modifiers'])
-
- def _create_text(self, data):
- return data
-
- def _invalid_placeholder(self, placeholder, remove):
- buf = self._view.get_buffer()
-
- # Remove the text because this placeholder is invalid
- if placeholder.default and remove:
- buf.delete(placeholder.begin_iter(), placeholder.end_iter())
-
- placeholder.remove()
-
- if placeholder.tabstop == -1:
- index = self.placeholders[-1].index(placeholder)
- del self.placeholders[-1][index]
- else:
- del self.placeholders[placeholder.tabstop]
-
- self.plugin_data.ordered_placeholders.remove(placeholder)
-
- def _parse(self, plugin_data):
- # Initialize current variables
- self._view = plugin_data.view
- self._indent = compute_indentation(self._view,
self._view.get_buffer().get_iter_at_mark(self.begin_mark))
- self._utils = EvalUtilities(self._view)
- self.placeholders = {}
- self._insert_mark = self.end_mark
- self.plugin_data = plugin_data
-
- # Create parser
- parser = Parser(data=self['text'])
-
- # Parse tokens
- while (True):
- token = parser.token()
-
- if not token:
- break
-
- try:
- val = {'environment': self._create_environment,
- 'placeholder': self._create_placeholder,
- 'shell': self._create_shell,
- 'eval': self._create_eval,
- 'regex': self._create_regex,
- 'text': self._create_text}[token.klass](token.data)
- except KeyError:
- sys.stderr.write('Token class not supported: %s (%s)\n' % token.klass)
- continue
-
- if isinstance(val, str):
- # Insert text
- self._insert_text(val)
- else:
- # Insert placeholder
- self._add_placeholder(val)
-
- # Create end placeholder if there isn't one yet
- if 0 not in self.placeholders:
- self.placeholders[0] = PlaceholderEnd(self._view, self.environ, self.end_iter(),
None)
- self.plugin_data.ordered_placeholders.append(self.placeholders[0])
-
- # Make sure run_last is ran for all placeholders and remove any
- # non `ok` placeholders
- for tabstop in self.placeholders.copy():
- ph = (tabstop == -1 and list(self.placeholders[-1])) or [self.placeholders[tabstop]]
-
- for placeholder in ph:
- placeholder.run_last(self.placeholders)
-
- if not placeholder.ok or placeholder.done:
- self._invalid_placeholder(placeholder, not placeholder.ok)
-
- # Remove all the Expand placeholders which have a tabstop because
- # they can be used to mirror, but they shouldn't be real tabstops
- # (if they have mirrors installed). This is problably a bit of
- # a dirty hack :)
- if -1 not in self.placeholders:
- self.placeholders[-1] = []
-
- for tabstop in self.placeholders.copy():
- placeholder = self.placeholders[tabstop]
-
- if tabstop != -1:
- if isinstance(placeholder, PlaceholderExpand) and \
- placeholder.has_references:
- # Add to anonymous placeholders
- self.placeholders[-1].append(placeholder)
-
- # Remove placeholder
- del self.placeholders[tabstop]
-
- self.plugin_data = None
-
- def insert_into(self, plugin_data, insert):
- buf = plugin_data.view.get_buffer()
- last_index = 0
-
- # Find closest mark at current insertion, so that we may insert
- # our marks in the correct order
- (current, next) = plugin_data.next_placeholder()
-
- if current:
- # Insert AFTER current
- last_index = plugin_data.placeholders.index(current) + 1
- elif next:
- # Insert BEFORE next
- last_index = plugin_data.placeholders.index(next)
- else:
- # Insert at first position
- last_index = 0
-
- # lastIndex now contains the position of the last mark
- # Create snippet bounding marks
- self.begin_mark = buf.create_mark(None, insert, True)
- self.end_mark = buf.create_mark(None, insert, False)
-
- # Now parse the contents of this snippet, create Placeholders
- # and insert the placholder marks in the marks array of plugin_data
- self._parse(plugin_data)
-
- # So now all of the snippet is in the buffer, we have all our
- # placeholders right here, what's next, put all marks in the
- # plugin_data.marks
- k = sorted(self.placeholders.keys(), reverse=True)
-
- plugin_data.placeholders.insert(last_index, self.placeholders[0])
- last_iter = self.placeholders[0].end_iter()
-
- for tabstop in k:
- if tabstop != -1 and tabstop != 0:
- placeholder = self.placeholders[tabstop]
- end_iter = placeholder.end_iter()
-
- if last_iter.compare(end_iter) < 0:
- last_iter = end_iter
-
- # Inserting placeholder
- plugin_data.placeholders.insert(last_index, placeholder)
-
- # Move end mark to last placeholder
- buf.move_mark(self.end_mark, last_iter)
-
- return self
-
- def deactivate(self):
- buf = self.begin_mark.get_buffer()
+ def display(self):
+ nm = helper.markup_escape(self['description'])
+
+ tag = self['tag']
+ accel = self.accelerator_display()
+ detail = []
+
+ if tag and tag != '':
+ detail.append(tag)
+
+ if accel and accel != '':
+ detail.append(accel)
+
+ if not detail:
+ return nm
+ else:
+ return nm + ' (<b>' + helper.markup_escape(', '.join(detail)) + \
+ '</b>)'
+
+ def _add_placeholder(self, placeholder):
+ if placeholder.tabstop in self.placeholders:
+ if placeholder.tabstop == -1:
+ self.placeholders[-1].append(placeholder)
+ self.plugin_data.ordered_placeholders.append(placeholder)
+ elif placeholder.tabstop == -1:
+ self.placeholders[-1] = [placeholder]
+ self.plugin_data.ordered_placeholders.append(placeholder)
+ else:
+ self.placeholders[placeholder.tabstop] = placeholder
+ self.plugin_data.ordered_placeholders.append(placeholder)
+
+ def _insert_text(self, text):
+ # Insert text keeping indentation in mind
+ indented = str.join('\n' + self._indent, helper.spaces_instead_of_tabs(self._view, text).split('\n'))
+ self._view.get_buffer().insert(self._insert_iter(), indented)
+
+ def _insert_iter(self):
+ return self._view.get_buffer().get_iter_at_mark(self._insert_mark)
+
+ def _create_environment(self, data):
+ if data in self.environ['utf8']:
+ val = self.environ['utf8'][data]
+ else:
+ val = ''
+
+ # Get all the current indentation
+ all_indent = helper.compute_indentation(self._view, self._insert_iter())
+
+ # Substract initial indentation to get the snippet indentation
+ indent = all_indent[len(self._indent):]
+
+ # Keep indentation
+ return str.join('\n' + indent, val.split('\n'))
+
+ def _create_placeholder(self, data):
+ tabstop = data['tabstop']
+ begin = self._insert_iter()
+
+ if tabstop == 0:
+ # End placeholder
+ return PlaceholderEnd(self._view, self.environ, begin, data['default'])
+ elif tabstop in self.placeholders:
+ # Mirror placeholder
+ return PlaceholderMirror(self._view, tabstop, self.environ, begin)
+ else:
+ # Default placeholder
+ return Placeholder(self._view, tabstop, self.environ, data['default'], begin)
+
+ def _create_shell(self, data):
+ begin = self._insert_iter()
+ return PlaceholderShell(self._view, data['tabstop'], self.environ, begin, data['contents'])
+
+ def _create_eval(self, data):
+ begin = self._insert_iter()
+ return PlaceholderEval(self._view, data['tabstop'], self.environ, data['dependencies'], begin,
data['contents'], self._utils.namespace)
+
+ def _create_regex(self, data):
+ begin = self._insert_iter()
+ return PlaceholderRegex(self._view, data['tabstop'], self.environ, begin, data['input'],
data['pattern'], data['substitution'], data['modifiers'])
+
+ def _create_text(self, data):
+ return data
+
+ def _invalid_placeholder(self, placeholder, remove):
+ buf = self._view.get_buffer()
+
+ # Remove the text because this placeholder is invalid
+ if placeholder.default and remove:
+ buf.delete(placeholder.begin_iter(), placeholder.end_iter())
+
+ placeholder.remove()
+
+ if placeholder.tabstop == -1:
+ index = self.placeholders[-1].index(placeholder)
+ del self.placeholders[-1][index]
+ else:
+ del self.placeholders[placeholder.tabstop]
+
+ self.plugin_data.ordered_placeholders.remove(placeholder)
+
+ def _parse(self, plugin_data):
+ # Initialize current variables
+ self._view = plugin_data.view
+ self._indent = helper.compute_indentation(self._view,
self._view.get_buffer().get_iter_at_mark(self.begin_mark))
+ self._utils = EvalUtilities(self._view)
+ self.placeholders = {}
+ self._insert_mark = self.end_mark
+ self.plugin_data = plugin_data
+
+ # Create parser
+ parser = Parser(data=self['text'])
+
+ # Parse tokens
+ while (True):
+ token = parser.token()
+
+ if not token:
+ break
+
+ try:
+ val = {'environment': self._create_environment,
+ 'placeholder': self._create_placeholder,
+ 'shell': self._create_shell,
+ 'eval': self._create_eval,
+ 'regex': self._create_regex,
+ 'text': self._create_text}[token.klass](token.data)
+ except KeyError:
+ sys.stderr.write('Token class not supported: %s (%s)\n' % token.klass)
+ continue
+
+ if isinstance(val, str):
+ # Insert text
+ self._insert_text(val)
+ else:
+ # Insert placeholder
+ self._add_placeholder(val)
+
+ # Create end placeholder if there isn't one yet
+ if 0 not in self.placeholders:
+ self.placeholders[0] = PlaceholderEnd(self._view, self.environ, self.end_iter(), None)
+ self.plugin_data.ordered_placeholders.append(self.placeholders[0])
+
+ # Make sure run_last is ran for all placeholders and remove any
+ # non `ok` placeholders
+ for tabstop in self.placeholders.copy():
+ ph = (tabstop == -1 and list(self.placeholders[-1])) or [self.placeholders[tabstop]]
+
+ for placeholder in ph:
+ placeholder.run_last(self.placeholders)
+
+ if not placeholder.ok or placeholder.done:
+ self._invalid_placeholder(placeholder, not placeholder.ok)
+
+ # Remove all the Expand placeholders which have a tabstop because
+ # they can be used to mirror, but they shouldn't be real tabstops
+ # (if they have mirrors installed). This is problably a bit of
+ # a dirty hack :)
+ if -1 not in self.placeholders:
+ self.placeholders[-1] = []
+
+ for tabstop in self.placeholders.copy():
+ placeholder = self.placeholders[tabstop]
+
+ if tabstop != -1:
+ if isinstance(placeholder, PlaceholderExpand) and \
+ placeholder.has_references:
+ # Add to anonymous placeholders
+ self.placeholders[-1].append(placeholder)
+
+ # Remove placeholder
+ del self.placeholders[tabstop]
+
+ self.plugin_data = None
+
+ def insert_into(self, plugin_data, insert):
+ buf = plugin_data.view.get_buffer()
+ last_index = 0
+
+ # Find closest mark at current insertion, so that we may insert
+ # our marks in the correct order
+ (current, next) = plugin_data.next_placeholder()
+
+ if current:
+ # Insert AFTER current
+ last_index = plugin_data.placeholders.index(current) + 1
+ elif next:
+ # Insert BEFORE next
+ last_index = plugin_data.placeholders.index(next)
+ else:
+ # Insert at first position
+ last_index = 0
+
+ # lastIndex now contains the position of the last mark
+ # Create snippet bounding marks
+ self.begin_mark = buf.create_mark(None, insert, True)
+ self.end_mark = buf.create_mark(None, insert, False)
+
+ # Now parse the contents of this snippet, create Placeholders
+ # and insert the placholder marks in the marks array of plugin_data
+ self._parse(plugin_data)
+
+ # So now all of the snippet is in the buffer, we have all our
+ # placeholders right here, what's next, put all marks in the
+ # plugin_data.marks
+ k = sorted(self.placeholders.keys(), reverse=True)
+
+ plugin_data.placeholders.insert(last_index, self.placeholders[0])
+ last_iter = self.placeholders[0].end_iter()
+
+ for tabstop in k:
+ if tabstop != -1 and tabstop != 0:
+ placeholder = self.placeholders[tabstop]
+ end_iter = placeholder.end_iter()
+
+ if last_iter.compare(end_iter) < 0:
+ last_iter = end_iter
+
+ # Inserting placeholder
+ plugin_data.placeholders.insert(last_index, placeholder)
+
+ # Move end mark to last placeholder
+ buf.move_mark(self.end_mark, last_iter)
+
+ return self
+
+ def deactivate(self):
+ buf = self.begin_mark.get_buffer()
- buf.delete_mark(self.begin_mark)
- buf.delete_mark(self.end_mark)
+ buf.delete_mark(self.begin_mark)
+ buf.delete_mark(self.end_mark)
- self.placeholders = {}
+ self.placeholders = {}
- def begin_iter(self):
- return self.begin_mark.get_buffer().get_iter_at_mark(self.begin_mark)
+ def begin_iter(self):
+ return self.begin_mark.get_buffer().get_iter_at_mark(self.begin_mark)
- def end_iter(self):
- return self.end_mark.get_buffer().get_iter_at_mark(self.end_mark)
+ def end_iter(self):
+ return self.end_mark.get_buffer().get_iter_at_mark(self.end_mark)
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/substitutionparser.py b/plugins/snippets/snippets/substitutionparser.py
index 45aa1f9..da62f7b 100644
--- a/plugins/snippets/snippets/substitutionparser.py
+++ b/plugins/snippets/snippets/substitutionparser.py
@@ -18,186 +18,186 @@
import re
class ParseError(Exception):
- def __str__(self):
- return 'Parse error, resume next'
+ def __str__(self):
+ return 'Parse error, resume next'
class Modifiers:
- def _first_char(s):
- first = (s != '' and s[0]) or ''
- rest = (len(s) > 1 and s[1:]) or ''
+ def _first_char(s):
+ first = (s != '' and s[0]) or ''
+ rest = (len(s) > 1 and s[1:]) or ''
- return first, rest
+ return first, rest
- def upper_first(s):
- first, rest = Modifiers._first_char(s)
+ def upper_first(s):
+ first, rest = Modifiers._first_char(s)
- return '%s%s' % (first.upper(), rest)
+ return '%s%s' % (first.upper(), rest)
- def upper(s):
- return s.upper()
+ def upper(s):
+ return s.upper()
- def lower_first(s):
- first, rest = Modifiers._first_char(s)
+ def lower_first(s):
+ first, rest = Modifiers._first_char(s)
- return '%s%s' % (first.lower(), rest)
+ return '%s%s' % (first.lower(), rest)
- def lower(s):
- return s.lower()
+ def lower(s):
+ return s.lower()
- def title(s):
- return s.title()
+ def title(s):
+ return s.title()
- upper_first = staticmethod(upper_first)
- upper = staticmethod(upper)
- lower_first = staticmethod(lower_first)
- lower = staticmethod(lower)
- title = staticmethod(title)
- _first_char = staticmethod(_first_char)
+ upper_first = staticmethod(upper_first)
+ upper = staticmethod(upper)
+ lower_first = staticmethod(lower_first)
+ lower = staticmethod(lower)
+ title = staticmethod(title)
+ _first_char = staticmethod(_first_char)
class SubstitutionParser:
- REG_ID = '[0-9]+'
- REG_NAME = '[a-zA-Z_]+'
- REG_MOD = '[a-zA-Z]+'
- REG_ESCAPE = '\\\\|\\(\\?|,|\\)'
+ REG_ID = '[0-9]+'
+ REG_NAME = '[a-zA-Z_]+'
+ REG_MOD = '[a-zA-Z]+'
+ REG_ESCAPE = '\\\\|\\(\\?|,|\\)'
- def __init__(self, pattern, groups = {}, modifiers = {}):
- self.pattern = pattern
- self.groups = groups
+ REG_GROUP = '(?:(%s)|<(%s|%s)(?:,(%s))?>)' % (REG_ID, REG_ID, REG_NAME, REG_MOD)
- self.REG_GROUP = '(?:(%s)|<(%s|%s)(?:,(%s))?>)' % (self.REG_ID, self.REG_ID, self.REG_NAME,
self.REG_MOD)
- self.modifiers = {'u': Modifiers.upper_first,
- 'U': Modifiers.upper,
- 'l': Modifiers.lower_first,
- 'L': Modifiers.lower,
- 't': Modifiers.title}
+ def __init__(self, pattern, groups = {}, modifiers = {}):
+ self.pattern = pattern
+ self.groups = groups
- for k, v in modifiers.items():
- self.modifiers[k] = v
+ self.modifiers = {'u': Modifiers.upper_first,
+ 'U': Modifiers.upper,
+ 'l': Modifiers.lower_first,
+ 'L': Modifiers.lower,
+ 't': Modifiers.title}
- def parse(self):
- result, tokens = self._parse(self.pattern, None)
+ for k, v in modifiers.items():
+ self.modifiers[k] = v
- return result
+ def parse(self):
+ result, tokens = self._parse(self.pattern, None)
- def _parse(self, tokens, terminator):
- result = ''
+ return result
- while tokens != '':
- if self._peek(tokens) == '' or self._peek(tokens) == terminator:
- tokens = self._remains(tokens)
- break
+ def _parse(self, tokens, terminator):
+ result = ''
- try:
- res, tokens = self._expr(tokens, terminator)
- except ParseError:
- res, tokens = self._text(tokens)
+ while tokens != '':
+ if self._peek(tokens) == '' or self._peek(tokens) == terminator:
+ tokens = self._remains(tokens)
+ break
- result += res
+ try:
+ res, tokens = self._expr(tokens, terminator)
+ except ParseError:
+ res, tokens = self._text(tokens)
- return result, tokens
+ result += res
- def _peek(self, tokens, num = 0):
- return (num < len(tokens) and tokens[num])
+ return result, tokens
- def _token(self, tokens):
- if tokens == '':
- return '', '';
+ def _peek(self, tokens, num = 0):
+ return (num < len(tokens) and tokens[num])
- return tokens[0], (len(tokens) > 1 and tokens[1:]) or ''
+ def _token(self, tokens):
+ if tokens == '':
+ return '', '';
- def _remains(self, tokens, num = 1):
- return (num < len(tokens) and tokens[num:]) or ''
+ return tokens[0], (len(tokens) > 1 and tokens[1:]) or ''
- def _expr(self, tokens, terminator):
- if tokens == '':
- return ''
+ def _remains(self, tokens, num = 1):
+ return (num < len(tokens) and tokens[num:]) or ''
- try:
- return {'\\': self._escape,
- '(': self._condition}[self._peek(tokens)](tokens, terminator)
- except KeyError:
- raise ParseError
+ def _expr(self, tokens, terminator):
+ if tokens == '':
+ return ''
- def _text(self, tokens):
- return self._token(tokens)
+ try:
+ return {'\\': self._escape,
+ '(': self._condition}[self._peek(tokens)](tokens, terminator)
+ except KeyError:
+ raise ParseError
- def _substitute(self, group, modifiers = ''):
- result = (self.groups.has_key(group) and self.groups[group]) or ''
+ def _text(self, tokens):
+ return self._token(tokens)
- for modifier in modifiers:
- if self.modifiers.has_key(modifier):
- result = self.modifiers[modifier](result)
+ def _substitute(self, group, modifiers = ''):
+ result = (self.groups.has_key(group) and self.groups[group]) or ''
- return result
+ for modifier in modifiers:
+ if self.modifiers.has_key(modifier):
+ result = self.modifiers[modifier](result)
- def _match_group(self, tokens):
- match = re.match('\\\\%s' % self.REG_GROUP, tokens)
+ return result
- if not match:
- return None, tokens
+ def _match_group(self, tokens):
+ match = re.match('\\\\%s' % self.REG_GROUP, tokens)
- return self._substitute(match.group(1) or match.group(2), match.group(3) or ''),
tokens[match.end():]
+ if not match:
+ return None, tokens
- def _escape(self, tokens, terminator):
- # Try to match a group
- result, tokens = self._match_group(tokens)
+ return self._substitute(match.group(1) or match.group(2), match.group(3) or ''), tokens[match.end():]
- if result != None:
- return result, tokens
+ def _escape(self, tokens, terminator):
+ # Try to match a group
+ result, tokens = self._match_group(tokens)
- s = self.REG_GROUP
+ if result != None:
+ return result, tokens
- if terminator:
- s += '|%s' % re.escape(terminator)
+ s = self.REG_GROUP
- match = re.match('\\\\(\\\\%s|%s)' % (s, self.REG_ESCAPE), tokens)
+ if terminator:
+ s += '|%s' % re.escape(terminator)
- if not match:
- raise ParseError
+ match = re.match('\\\\(\\\\%s|%s)' % (s, self.REG_ESCAPE), tokens)
- return match.group(1), tokens[match.end():]
+ if not match:
+ raise ParseError
- def _condition_value(self, tokens):
- match = re.match('\\\\?%s\s*' % self.REG_GROUP, tokens)
+ return match.group(1), tokens[match.end():]
- if not match:
- return None, tokens
+ def _condition_value(self, tokens):
+ match = re.match('\\\\?%s\s*' % self.REG_GROUP, tokens)
- groups = match.groups()
- name = groups[0] or groups[1]
+ if not match:
+ return None, tokens
- return self.groups.has_key(name) and self.groups[name] != None, tokens[match.end():]
+ groups = match.groups()
+ name = groups[0] or groups[1]
- def _condition(self, tokens, terminator):
- # Match ? after (
- if self._peek(tokens, 1) != '?':
- raise ParseError
+ return self.groups.has_key(name) and self.groups[name] != None, tokens[match.end():]
- # Remove initial (? token
- tokens = self._remains(tokens, 2)
- condition, tokens = self._condition_value(tokens)
+ def _condition(self, tokens, terminator):
+ # Match ? after (
+ if self._peek(tokens, 1) != '?':
+ raise ParseError
- if condition == None or self._peek(tokens) != ',':
- raise ParseError
+ # Remove initial (? token
+ tokens = self._remains(tokens, 2)
+ condition, tokens = self._condition_value(tokens)
- truepart, tokens = self._parse(self._remains(tokens), ',')
+ if condition == None or self._peek(tokens) != ',':
+ raise ParseError
- if truepart == None:
- raise ParseError
+ truepart, tokens = self._parse(self._remains(tokens), ',')
- falsepart, tokens = self._parse(tokens, ')')
+ if truepart == None:
+ raise ParseError
- if falsepart == None:
- raise ParseError
+ falsepart, tokens = self._parse(tokens, ')')
- if condition:
- return truepart, tokens
- else:
- return falsepart, tokens
+ if falsepart == None:
+ raise ParseError
- def escape_substitution(substitution):
- return re.sub('(%s|%s)' % (self.REG_GROUP, self.REG_ESCAPE), '\\\\\\1', substitution)
+ if condition:
+ return truepart, tokens
+ else:
+ return falsepart, tokens
- escapesubstitution = staticmethod(escape_substitution)
+ @staticmethod
+ def escape_substitution(substitution):
+ return re.sub('(%s|%s)' % (SubstitutionParser.REG_GROUP, SubstitutionParser.REG_ESCAPE), '\\\\\\1',
substitution)
-# ex:ts=8:et:
+# ex:ts=4:et:
diff --git a/plugins/snippets/snippets/windowactivatable.py b/plugins/snippets/snippets/windowactivatable.py
index 4ae9c5d..8f2d74a 100644
--- a/plugins/snippets/snippets/windowactivatable.py
+++ b/plugins/snippets/snippets/windowactivatable.py
@@ -15,176 +15,172 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-import re
-import os
-import gettext
+from gi.repository import Gtk, Gedit, GObject
-from gi.repository import Gtk, Gdk, Gedit, GObject, Gio
-
-from .document import Document
+from .snippet import Snippet
from .library import Library
from .shareddata import SharedData
from .signals import Signals
class Message(Gedit.Message):
- view = GObject.property(type=Gedit.View)
- iter = GObject.property(type=Gtk.TextIter)
+ view = GObject.property(type=Gedit.View)
+ iter = GObject.property(type=Gtk.TextIter)
class Activate(Message):
- trigger = GObject.property(type=str)
+ trigger = GObject.property(type=str)
class ParseAndActivate(Message):
- snippet = GObject.property(type=str)
+ snippet = GObject.property(type=str)
class WindowActivatable(GObject.Object, Gedit.WindowActivatable, Signals):
- __gtype_name__ = "GeditSnippetsWindowActivatable"
+ __gtype_name__ = "GeditSnippetsWindowActivatable"
- window = GObject.property(type=Gedit.Window)
+ window = GObject.property(type=Gedit.Window)
- def __init__(self):
- GObject.Object.__init__(self)
- Signals.__init__(self)
+ def __init__(self):
+ GObject.Object.__init__(self)
+ Signals.__init__(self)
- self.current_language_accel_group = None
+ self.current_language_accel_group = None
- def do_activate(self):
- self.register_messages()
+ def do_activate(self):
+ self.register_messages()
- library = Library()
- library.add_accelerator_callback(self.accelerator_activated)
+ library = Library()
+ library.add_accelerator_callback(self.accelerator_activated)
- self.accel_group = Library().get_accel_group(None)
+ self.accel_group = Library().get_accel_group(None)
- if self.accel_group:
- self.window.add_accel_group(self.accel_group)
+ if self.accel_group:
+ self.window.add_accel_group(self.accel_group)
- self.connect_signal(self.window,
- 'active-tab-changed',
- self.on_active_tab_changed)
+ self.connect_signal(self.window,
+ 'active-tab-changed',
+ self.on_active_tab_changed)
- self.do_update_state()
+ self.do_update_state()
- SharedData().register_window(self)
+ SharedData().register_window(self)
- def do_deactivate(self):
- if self.accel_group:
- self.window.remove_accel_group(self.accel_group)
+ def do_deactivate(self):
+ if self.accel_group:
+ self.window.remove_accel_group(self.accel_group)
- self.accel_group = None
+ self.accel_group = None
- self.unregister_messages()
+ self.unregister_messages()
- library = Library()
- library.remove_accelerator_callback(self.accelerator_activated)
+ library = Library()
+ library.remove_accelerator_callback(self.accelerator_activated)
- self.disconnect_signals(self.window)
+ self.disconnect_signals(self.window)
- SharedData().unregister_window(self)
+ SharedData().unregister_window(self)
- def do_update_state(self):
- controller = SharedData().get_active_controller(self.window)
+ def do_update_state(self):
+ controller = SharedData().get_active_controller(self.window)
- self.update_language(controller)
+ self.update_language(controller)
- def register_messages(self):
- bus = self.window.get_message_bus()
+ def register_messages(self):
+ bus = self.window.get_message_bus()
- bus.register(Activate, '/plugins/snippets', 'activate')
- bus.register(ParseAndActivate, '/plugins/snippets', 'parse-and-activate')
+ bus.register(Activate, '/plugins/snippets', 'activate')
+ bus.register(ParseAndActivate, '/plugins/snippets', 'parse-and-activate')
- self.signal_ids = set()
+ self.signal_ids = set()
- sid = bus.connect('/plugins/snippets', 'activate', self.on_message_activate, None)
- self.signal_ids.add(sid)
+ sid = bus.connect('/plugins/snippets', 'activate', self.on_message_activate, None)
+ self.signal_ids.add(sid)
- sid = bus.connect('/plugins/snippets', 'parse-and-activate',
self.on_message_parse_and_activate, None)
- self.signal_ids.add(sid)
+ sid = bus.connect('/plugins/snippets', 'parse-and-activate', self.on_message_parse_and_activate,
None)
+ self.signal_ids.add(sid)
- def unregister_messages(self):
- bus = self.window.get_message_bus()
- for sid in self.signal_ids:
- bus.disconnect(sid)
- signal_ids = None
- bus.unregister_all('/plugins/snippets')
+ def unregister_messages(self):
+ bus = self.window.get_message_bus()
+ for sid in self.signal_ids:
+ bus.disconnect(sid)
+ self.signal_ids = set()
+ bus.unregister_all('/plugins/snippets')
- def on_message_activate(self, bus, message, userdata):
- view = message.props.view
+ def on_message_activate(self, bus, message, userdata):
+ view = message.props.view
- if not view:
- view = self.window.get_active_view()
+ if not view:
+ view = self.window.get_active_view()
- controller = SharedData().get_controller(view)
+ controller = SharedData().get_controller(view)
- if not controller:
- return
+ if not controller:
+ return
- iter = message.props.iter
+ iter = message.props.iter
- if not iter:
- iter = view.get_buffer().get_iter_at_mark(view.get_buffer().get_insert())
+ if not iter:
+ iter = view.get_buffer().get_iter_at_mark(view.get_buffer().get_insert())
- controller.run_snippet_trigger(message.props.trigger, (iter, iter))
+ controller.run_snippet_trigger(message.props.trigger, (iter, iter))
- def on_message_parse_and_activate(self, bus, message, userdata):
- view = message.props.view
+ def on_message_parse_and_activate(self, bus, message, userdata):
+ view = message.props.view
- if not view:
- view = self.window.get_active_view()
+ if not view:
+ view = self.window.get_active_view()
- controller = SharedData().get_controller(view)
+ controller = SharedData().get_controller(view)
- if not controller:
- return
+ if not controller:
+ return
- iter = message.props.iter
-
- if not iter:
- iter = view.get_buffer().get_iter_at_mark(view.get_buffer().get_insert())
+ iter = message.props.iter
+
+ if not iter:
+ iter = view.get_buffer().get_iter_at_mark(view.get_buffer().get_insert())
- controller.parse_and_run_snippet(message.props.snippet, iter)
+ controller.parse_and_run_snippet(message.props.snippet, iter)
- def find_snippet(self, snippets, tag):
- result = []
+ def find_snippet(self, snippets, tag):
+ result = []
- for snippet in snippets:
- if Snippet(snippet)['tag'] == tag:
- result.append(snippet)
+ for snippet in snippets:
+ if Snippet(snippet)['tag'] == tag:
+ result.append(snippet)
- return result
+ return result
- def update_language(self, controller):
- if not self.window:
- return
+ def update_language(self, controller):
+ if not self.window:
+ return
- if controller:
- langid = controller.language_id
- else:
- langid = None
+ if controller:
+ langid = controller.language_id
+ else:
+ langid = None
- if langid != None:
- accelgroup = Library().get_accel_group(langid)
- else:
- accelgroup = None
+ if langid != None:
+ accelgroup = Library().get_accel_group(langid)
+ else:
+ accelgroup = None
- if accelgroup != self.current_language_accel_group:
- if self.current_language_accel_group:
- self.window.remove_accel_group(self.current_language_accel_group)
+ if accelgroup != self.current_language_accel_group:
+ if self.current_language_accel_group:
+ self.window.remove_accel_group(self.current_language_accel_group)
- if accelgroup:
- self.window.add_accel_group(accelgroup)
+ if accelgroup:
+ self.window.add_accel_group(accelgroup)
- self.current_language_accel_group = accelgroup
+ self.current_language_accel_group = accelgroup
- def on_active_tab_changed(self, window, tab):
- self.update_language(SharedData().get_controller(tab.get_view()))
+ def on_active_tab_changed(self, window, tab):
+ self.update_language(SharedData().get_controller(tab.get_view()))
- def accelerator_activated(self, group, obj, keyval, mod):
- if obj == self.window:
- controller = SharedData().get_active_controller(self.window)
+ def accelerator_activated(self, group, obj, keyval, mod):
+ if obj == self.window:
+ controller = SharedData().get_active_controller(self.window)
- if controller:
- return controller.accelerator_activate(keyval, mod)
- else:
- return False
+ if controller:
+ return controller.accelerator_activate(keyval, mod)
+ else:
+ return False
-# ex:ts=8:et:
+# ex:ts=4:et:
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
