Reorganize custom widgets into a new 'widgets' package.
1. moving existing widget modules under src/widgets/ svn: r10694
This commit is contained in:
Zsolt Foldvari
@@ -0,0 +1,600 @@
|
||||
#
|
||||
# Gramps - a GTK+/GNOME based genealogy program
|
||||
#
|
||||
# Copyright (C) 2007-2008 Zsolt Foldvari
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
#
|
||||
|
||||
# $Id$
|
||||
|
||||
"Text buffer subclassed from gtk.TextBuffer handling L{StyledText}."
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# Python modules
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
from gettext import gettext as _
|
||||
import re
|
||||
|
||||
import logging
|
||||
_LOG = logging.getLogger(".Editors.StyledTextBuffer")
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# GTK modules
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
import gobject
|
||||
import gtk
|
||||
from pango import WEIGHT_BOLD, STYLE_ITALIC, UNDERLINE_SINGLE
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# GRAMPS modules
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
from gen.lib import (StyledText, StyledTextTag, StyledTextTagType)
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# Constants
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
ALLOWED_STYLES = (
|
||||
StyledTextTagType.BOLD,
|
||||
StyledTextTagType.ITALIC,
|
||||
StyledTextTagType.UNDERLINE,
|
||||
StyledTextTagType.FONTCOLOR,
|
||||
StyledTextTagType.HIGHLIGHT,
|
||||
StyledTextTagType.FONTFACE,
|
||||
StyledTextTagType.FONTSIZE,
|
||||
)
|
||||
|
||||
STYLE_TO_PROPERTY = {
|
||||
StyledTextTagType.BOLD: 'weight', # permanent tag is used instead
|
||||
StyledTextTagType.ITALIC: 'style', # permanent tag is used instead
|
||||
StyledTextTagType.UNDERLINE: 'underline', # permanent tag is used instead
|
||||
StyledTextTagType.FONTCOLOR: 'foreground',
|
||||
StyledTextTagType.HIGHLIGHT: 'background',
|
||||
StyledTextTagType.FONTFACE: 'family',
|
||||
StyledTextTagType.FONTSIZE: 'size-points',
|
||||
}
|
||||
|
||||
(MATCH_START,
|
||||
MATCH_END,
|
||||
MATCH_FLAVOR,
|
||||
MATCH_STRING,) = range(4)
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# GtkSpellState class
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
class GtkSpellState:
|
||||
"""A simple state machine kinda thingy.
|
||||
|
||||
Trying to track gtk.Spell activities on a buffer and re-apply formatting
|
||||
after gtk.Spell replaces a misspelled word.
|
||||
|
||||
"""
|
||||
(STATE_NONE,
|
||||
STATE_CLICKED,
|
||||
STATE_DELETED,
|
||||
STATE_INSERTING) = range(4)
|
||||
|
||||
def __init__(self, textbuffer):
|
||||
if not isinstance(textbuffer, gtk.TextBuffer):
|
||||
raise TypeError("Init parameter must be instance of gtk.TextBuffer")
|
||||
|
||||
textbuffer.connect('mark-set', self.on_buffer_mark_set)
|
||||
textbuffer.connect('delete-range', self.on_buffer_delete_range)
|
||||
textbuffer.connect('insert-text', self.on_buffer_insert_text)
|
||||
textbuffer.connect_after('insert-text', self.after_buffer_insert_text)
|
||||
|
||||
self.reset_state()
|
||||
|
||||
def reset_state(self):
|
||||
self.state = self.STATE_NONE
|
||||
self.start = 0
|
||||
self.end = 0
|
||||
self.tags = None
|
||||
|
||||
def on_buffer_mark_set(self, textbuffer, iter, mark):
|
||||
mark_name = mark.get_name()
|
||||
if mark_name == 'gtkspell-click':
|
||||
self.state = self.STATE_CLICKED
|
||||
self.start, self.end = self.get_word_extents_from_mark(textbuffer,
|
||||
mark)
|
||||
_LOG.debug("SpellState got start %d end %d" % (self.start, self.end))
|
||||
elif mark_name == 'insert':
|
||||
self.reset_state()
|
||||
|
||||
def on_buffer_delete_range(self, textbuffer, start, end):
|
||||
if ((self.state == self.STATE_CLICKED) and
|
||||
(start.get_offset() == self.start) and
|
||||
(end.get_offset() == self.end)):
|
||||
self.state = self.STATE_DELETED
|
||||
self.tags = start.get_tags()
|
||||
|
||||
def on_buffer_insert_text(self, textbuffer, iter, text, length):
|
||||
if self.state == self.STATE_DELETED and iter.get_offset() == self.start:
|
||||
self.state = self.STATE_INSERTING
|
||||
|
||||
def after_buffer_insert_text(self, textbuffer, iter, text, length):
|
||||
if self.state == self.STATE_INSERTING:
|
||||
mark = textbuffer.get_mark('gtkspell-insert-start')
|
||||
insert_start = textbuffer.get_iter_at_mark(mark)
|
||||
for tag in self.tags:
|
||||
textbuffer.apply_tag(tag, insert_start, iter)
|
||||
|
||||
self.reset_state()
|
||||
|
||||
def get_word_extents_from_mark(self, textbuffer, mark):
|
||||
"""Get the word extents as gtk.Spell does.
|
||||
|
||||
Used to get the beginning of the word, in which user right clicked.
|
||||
Formatting found at that position used after gtk.Spell replaces
|
||||
misspelled words.
|
||||
|
||||
"""
|
||||
start = textbuffer.get_iter_at_mark(mark)
|
||||
if not start.starts_word():
|
||||
#start.backward_word_start()
|
||||
self.backward_word_start(start)
|
||||
end = start.copy()
|
||||
if end.inside_word():
|
||||
#end.forward_word_end()
|
||||
self.forward_word_end(end)
|
||||
return start.get_offset(), end.get_offset()
|
||||
|
||||
def forward_word_end(self, iter):
|
||||
"""gtk.Spell style gtk.TextIter.forward_word_end.
|
||||
|
||||
The parameter 'iter' is changing as side effect.
|
||||
|
||||
"""
|
||||
if not iter.forward_word_end():
|
||||
return False
|
||||
|
||||
if iter.get_char() != "'":
|
||||
return True
|
||||
|
||||
i = iter.copy()
|
||||
if i.forward_char():
|
||||
if i.get_char().isalpha():
|
||||
return iter.forward_word_end()
|
||||
|
||||
return True
|
||||
|
||||
def backward_word_start(self, iter):
|
||||
"""gtk.Spell style gtk.TextIter.backward_word_start.
|
||||
|
||||
The parameter 'iter' is changing as side effect.
|
||||
|
||||
"""
|
||||
if not iter.backward_word_start():
|
||||
return False
|
||||
|
||||
i = iter.copy()
|
||||
if i.backward_char():
|
||||
if i.get_char() == "'":
|
||||
if i.backward_char():
|
||||
if i.get_char().isalpha():
|
||||
return iter.backward_word_start()
|
||||
|
||||
return True
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# StyledTextBuffer class
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
class StyledTextBuffer(gtk.TextBuffer):
|
||||
"""An extended TextBuffer for handling StyledText strings.
|
||||
|
||||
StyledTextBuffer is an interface between GRAMPS' L{StyledText} format
|
||||
and gtk.TextBuffer. To set and get the text use the L{set_text} and
|
||||
L{get_text} methods.
|
||||
|
||||
To set a style to (a portion of) the text (e.g. from GUI) use the
|
||||
L{apply_style} and L{remove_style} methods.
|
||||
|
||||
To receive information about the style of the text at the cursor position
|
||||
StyledTextBuffer provides two mechanism: message driven and polling.
|
||||
To receive notification of style change as cursor moves connect to the
|
||||
C{style-changed} signal. To get the value of a certain style at the cursor
|
||||
use the L{get_style_at_cursor) method.
|
||||
|
||||
StyledTextBuffer has a regexp pattern matching mechanism too. To add a
|
||||
regexp pattern to match in the text use the L{match_add} method. To check
|
||||
if there's a match at a certain position in the text use the L{match_check}
|
||||
method. For an example how to use the matching see L{EditNote}.
|
||||
|
||||
"""
|
||||
__gtype_name__ = 'StyledTextBuffer'
|
||||
|
||||
__gsignals__ = {
|
||||
'style-changed': (gobject.SIGNAL_RUN_FIRST,
|
||||
gobject.TYPE_NONE, #return value
|
||||
(gobject.TYPE_PYOBJECT,)), # arguments
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
gtk.TextBuffer.__init__(self)
|
||||
|
||||
# Create fix tags.
|
||||
# Other tags (e.g. color) have to be created on the fly
|
||||
# see self._find_tag_by_name
|
||||
self.create_tag(str(StyledTextTagType.BOLD), weight=WEIGHT_BOLD)
|
||||
self.create_tag(str(StyledTextTagType.ITALIC), style=STYLE_ITALIC)
|
||||
self.create_tag(str(StyledTextTagType.UNDERLINE),
|
||||
underline=UNDERLINE_SINGLE)
|
||||
|
||||
# internal format state attributes
|
||||
## 1. are used to format inserted characters (self.after_insert_text)
|
||||
## 2. are set each time the Insert marker is set (self.do_mark_set)
|
||||
## 3. are set when a style is set (self._apply_style_to_selection)
|
||||
self.style_state = StyledTextTagType.STYLE_DEFAULT.copy()
|
||||
|
||||
# internally used attribute
|
||||
self._insert = self.get_insert()
|
||||
|
||||
# create a mark used for text formatting
|
||||
start, end = self.get_bounds()
|
||||
self.mark_insert = self.create_mark('insert-start', start, True)
|
||||
|
||||
# pattern matching attributes
|
||||
self.patterns = []
|
||||
self.matches = []
|
||||
|
||||
# hook up on some signals whose default handler cannot be overriden
|
||||
self.connect('insert-text', self.on_insert_text)
|
||||
self.connect_after('insert-text', self.after_insert_text)
|
||||
self.connect_after('delete-range', self.after_delete_range)
|
||||
|
||||
# init gtkspell "state machine"
|
||||
self.gtkspell_state = GtkSpellState(self)
|
||||
|
||||
# Virtual methods
|
||||
|
||||
def on_insert_text(self, textbuffer, iter, text, length):
|
||||
_LOG.debug("Will insert at %d length %d" % (iter.get_offset(), length))
|
||||
|
||||
# let's remember where we started inserting
|
||||
self.move_mark(self.mark_insert, iter)
|
||||
|
||||
def after_insert_text(self, textbuffer, iter, text, length):
|
||||
"""Format inserted text."""
|
||||
_LOG.debug("Have inserted at %d length %d (%s)" %
|
||||
(iter.get_offset(), length, text))
|
||||
|
||||
if not length:
|
||||
return
|
||||
|
||||
# where did we start inserting
|
||||
insert_start = self.get_iter_at_mark(self.mark_insert)
|
||||
|
||||
# apply active formats for the inserted text
|
||||
for style in ALLOWED_STYLES:
|
||||
value = self.style_state[style]
|
||||
if value and (value != StyledTextTagType.STYLE_DEFAULT[style]):
|
||||
self.apply_tag(self._find_tag_by_name(style, value),
|
||||
insert_start, iter)
|
||||
|
||||
def after_delete_range(self, textbuffer, start, end):
|
||||
_LOG.debug("Deleted from %d till %d" %
|
||||
(start.get_offset(), end.get_offset()))
|
||||
|
||||
# move 'insert' marker to have the format attributes updated
|
||||
self.move_mark(self._insert, start)
|
||||
|
||||
def do_changed(self):
|
||||
"""Parse for patterns in the text."""
|
||||
self.matches = []
|
||||
text = unicode(gtk.TextBuffer.get_text(self,
|
||||
self.get_start_iter(),
|
||||
self.get_end_iter()))
|
||||
for regex, flavor in self.patterns:
|
||||
iter = regex.finditer(text)
|
||||
while True:
|
||||
try:
|
||||
match = iter.next()
|
||||
self.matches.append((match.start(), match.end(),
|
||||
flavor, match.group()))
|
||||
_LOG.debug("Matches: %d, %d: %s [%d]" %
|
||||
(match.start(), match.end(),
|
||||
match.group(), flavor))
|
||||
except StopIteration:
|
||||
break
|
||||
|
||||
def do_mark_set(self, iter, mark):
|
||||
"""Update style state each time the cursor moves."""
|
||||
_LOG.debug("Setting mark %s at %d" %
|
||||
(mark.get_name(), iter.get_offset()))
|
||||
|
||||
if mark.get_name() != 'insert':
|
||||
return
|
||||
|
||||
if not iter.starts_line():
|
||||
iter.backward_char()
|
||||
|
||||
tag_names = [tag.get_property('name') for tag in iter.get_tags()]
|
||||
changed_styles = {}
|
||||
|
||||
for style in ALLOWED_STYLES:
|
||||
if StyledTextTagType.STYLE_TYPE[style] == bool:
|
||||
value = str(style) in tag_names
|
||||
else:
|
||||
value = StyledTextTagType.STYLE_DEFAULT[style]
|
||||
for tname in tag_names:
|
||||
if tname.startswith(str(style)):
|
||||
value = tname.split(' ', 1)[1]
|
||||
value = StyledTextTagType.STYLE_TYPE[style](value)
|
||||
|
||||
if self.style_state[style] != value:
|
||||
changed_styles[style] = value
|
||||
|
||||
self.style_state[style] = value
|
||||
|
||||
if changed_styles:
|
||||
self.emit('style-changed', changed_styles)
|
||||
|
||||
# Private
|
||||
|
||||
##def get_tag_value_at_insert(self, name):
|
||||
##"""Get the value of the given tag at the insertion point."""
|
||||
##tags = self.get_iter_at_mark(self._insert).get_tags()
|
||||
|
||||
##if name in self.toggle_actions:
|
||||
##for tag in tags:
|
||||
##if tag.get_name() == name:
|
||||
##return True
|
||||
##return False
|
||||
##else:
|
||||
##for tag in tags:
|
||||
##if tag.get_name().startswith(name):
|
||||
##return tag.get_name().split()[1]
|
||||
##return None
|
||||
|
||||
def _get_selection(self):
|
||||
bounds = self.get_selection_bounds()
|
||||
if not bounds:
|
||||
iter = self.get_iter_at_mark(self._insert)
|
||||
if iter.inside_word():
|
||||
start_pos = iter.get_offset()
|
||||
iter.forward_word_end()
|
||||
word_end = iter.get_offset()
|
||||
iter.backward_word_start()
|
||||
word_start = iter.get_offset()
|
||||
iter.set_offset(start_pos)
|
||||
bounds = (self.get_iter_at_offset(word_start),
|
||||
self.get_iter_at_offset(word_end))
|
||||
else:
|
||||
bounds = (iter, self.get_iter_at_offset(iter.get_offset() + 1))
|
||||
return bounds
|
||||
|
||||
def _apply_tag_to_selection(self, tag):
|
||||
selection = self._get_selection()
|
||||
if selection:
|
||||
self.apply_tag(tag, *selection)
|
||||
|
||||
def _remove_tag_from_selection(self, tag):
|
||||
selection = self._get_selection()
|
||||
if selection:
|
||||
self.remove_tag(tag, *selection)
|
||||
|
||||
def _apply_style_to_selection(self, style, value):
|
||||
# FIXME can this be unified?
|
||||
if StyledTextTagType.STYLE_TYPE[style] == bool:
|
||||
start, end = self._get_selection()
|
||||
|
||||
if value:
|
||||
self.apply_tag_by_name(str(style), start, end)
|
||||
else:
|
||||
self.remove_tag_by_name(str(style), start, end)
|
||||
elif StyledTextTagType.STYLE_TYPE[style] == str:
|
||||
tag = self._find_tag_by_name(style, value)
|
||||
self._remove_style_from_selection(style)
|
||||
self._apply_tag_to_selection(tag)
|
||||
elif StyledTextTagType.STYLE_TYPE[style] == int:
|
||||
tag = self._find_tag_by_name(style, value)
|
||||
self._remove_style_from_selection(style)
|
||||
self._apply_tag_to_selection(tag)
|
||||
else:
|
||||
# we should never get until here
|
||||
return
|
||||
|
||||
self.style_state[style] = value
|
||||
|
||||
def _remove_style_from_selection(self, style):
|
||||
start, end = self._get_selection()
|
||||
tags = self._get_tag_from_range(start.get_offset(), end.get_offset())
|
||||
for tag_name in tags.keys():
|
||||
if tag_name.startswith(str(style)):
|
||||
for start, end in tags[tag_name]:
|
||||
self.remove_tag_by_name(tag_name,
|
||||
self.get_iter_at_offset(start),
|
||||
self.get_iter_at_offset(end+1))
|
||||
|
||||
def _get_tag_from_range(self, start=None, end=None):
|
||||
"""Extract gtk.TextTags from buffer.
|
||||
|
||||
Return only the name of the TextTag from the specified range.
|
||||
If range is not given, tags extracted from the whole buffer.
|
||||
|
||||
@note: TextTag names are always composed like: (%s %s) % (style, value)
|
||||
|
||||
@param start: an offset pointing to the start of the range of text
|
||||
@param type: int
|
||||
@param end: an offset pointing to the end of the range of text
|
||||
@param type: int
|
||||
@return: tagdict
|
||||
@rtype: {TextTag_Name: [(start, end),]}
|
||||
|
||||
"""
|
||||
if start is None:
|
||||
start = 0
|
||||
if end is None:
|
||||
end = self.get_char_count()
|
||||
|
||||
tagdict = {}
|
||||
for pos in range(start, end):
|
||||
iter = self.get_iter_at_offset(pos)
|
||||
for tag in iter.get_tags():
|
||||
name = tag.get_property('name')
|
||||
if tagdict.has_key(name):
|
||||
if tagdict[name][-1][1] == pos - 1:
|
||||
tagdict[name][-1] = (tagdict[name][-1][0], pos)
|
||||
else:
|
||||
tagdict[name].append((pos, pos))
|
||||
else:
|
||||
tagdict[name]=[(pos, pos)]
|
||||
return tagdict
|
||||
|
||||
def _find_tag_by_name(self, style, value):
|
||||
"""Fetch TextTag from buffer's tag table by it's name.
|
||||
|
||||
If TextTag does not exist yet, it is created.
|
||||
|
||||
"""
|
||||
if StyledTextTagType.STYLE_TYPE[style] == bool:
|
||||
tag_name = str(style)
|
||||
elif StyledTextTagType.STYLE_TYPE[style] == str:
|
||||
tag_name = "%d %s" % (style, value)
|
||||
elif StyledTextTagType.STYLE_TYPE[style] == int:
|
||||
tag_name = "%d %d" % (style, value)
|
||||
else:
|
||||
raise ValueError("Unknown style (%s) value type: %s" %
|
||||
(style, value.__class__))
|
||||
|
||||
tag = self.get_tag_table().lookup(tag_name)
|
||||
|
||||
if not tag:
|
||||
if StyledTextTagType.STYLE_TYPE[style] != bool:
|
||||
# bool style tags are not created here, but in constuctor
|
||||
tag = self.create_tag(tag_name)
|
||||
tag.set_property(STYLE_TO_PROPERTY[style], value)
|
||||
else:
|
||||
return None
|
||||
return tag
|
||||
|
||||
# Public API
|
||||
|
||||
def set_text(self, s_text):
|
||||
"""Set the content of the buffer with markup tags.
|
||||
|
||||
@note: 's_' prefix means StyledText*, while 'g_' prefix means gtk.*.
|
||||
|
||||
"""
|
||||
gtk.TextBuffer.set_text(self, str(s_text))
|
||||
|
||||
s_tags = s_text.get_tags()
|
||||
for s_tag in s_tags:
|
||||
g_tag = self._find_tag_by_name(int(s_tag.name), s_tag.value)
|
||||
if g_tag is not None:
|
||||
for (start, end) in s_tag.ranges:
|
||||
start_iter = self.get_iter_at_offset(start)
|
||||
end_iter = self.get_iter_at_offset(end)
|
||||
self.apply_tag(g_tag, start_iter, end_iter)
|
||||
|
||||
def get_text(self, start=None, end=None, include_hidden_chars=True):
|
||||
"""Return the buffer text.
|
||||
|
||||
@note: 's_' prefix means StyledText*, while 'g_' prefix means gtk.*.
|
||||
|
||||
"""
|
||||
if start is None:
|
||||
start = self.get_start_iter()
|
||||
if end is None:
|
||||
end = self.get_end_iter()
|
||||
|
||||
txt = gtk.TextBuffer.get_text(self, start, end, include_hidden_chars)
|
||||
txt = unicode(txt)
|
||||
|
||||
# extract tags out of the buffer
|
||||
g_tags = self._get_tag_from_range()
|
||||
s_tags = []
|
||||
|
||||
for g_tagname, g_ranges in g_tags.items():
|
||||
style_and_value = g_tagname.split(' ', 1)
|
||||
|
||||
try:
|
||||
style = int(style_and_value[0])
|
||||
if len(style_and_value) == 1:
|
||||
s_value = None
|
||||
else:
|
||||
s_value = StyledTextTagType.STYLE_TYPE[style]\
|
||||
(style_and_value[1])
|
||||
|
||||
if style in ALLOWED_STYLES:
|
||||
s_ranges = [(start, end+1) for (start, end) in g_ranges]
|
||||
s_tag = StyledTextTag(style, s_value, s_ranges)
|
||||
|
||||
s_tags.append(s_tag)
|
||||
except ValueError:
|
||||
_LOG.debug("silently skipping gtk.TextTag '%s'" % g_tagname)
|
||||
|
||||
return StyledText(txt, s_tags)
|
||||
|
||||
def apply_style(self, style, value):
|
||||
"""Apply a style with the given value to the selection.
|
||||
|
||||
@param style: style type to apply
|
||||
@type style: L{StyledTextTagStyle} int value
|
||||
@param value: value of the style type
|
||||
@type value: depends on the I{style} type
|
||||
|
||||
"""
|
||||
if not isinstance(value, StyledTextTagType.STYLE_TYPE[style]):
|
||||
raise TypeError("Style (%d) value must be %s and not %s" %
|
||||
(style, StyledTextTagType.STYLE_TYPE[style],
|
||||
value.__class__))
|
||||
|
||||
self._apply_style_to_selection(style, value)
|
||||
|
||||
def remove_style(self, style):
|
||||
"""Delete all occurences with any value of the given style.
|
||||
|
||||
@param style: style type to apply
|
||||
@type style: L{StyledTextTagStyle} int value
|
||||
|
||||
"""
|
||||
self._remove_style_from_selection(style)
|
||||
|
||||
def get_style_at_cursor(self, style):
|
||||
"""Get the actual value of the given style at the cursor position.
|
||||
|
||||
@param style: style type to apply
|
||||
@type style: L{StyledTextTagStyle} int value
|
||||
@returns: value of the style type
|
||||
@returntype: depends on the C{style} type
|
||||
|
||||
"""
|
||||
return self.style_state[style]
|
||||
|
||||
def match_add(self, pattern, flavor):
|
||||
"""Add a pattern to look for in the text."""
|
||||
regex = re.compile(pattern)
|
||||
self.patterns.append((regex, flavor))
|
||||
|
||||
def match_check(self, pos):
|
||||
"""Check if pos falls into any of the matched patterns."""
|
||||
for match in self.matches:
|
||||
if pos >= match[MATCH_START] and pos <= match[MATCH_END]:
|
||||
return match
|
||||
|
||||
return None
|
||||
Reference in New Issue
Block a user