def AutoIndenter(stc, pos, ichar):
"""Auto indent cpp code. uses \n the text buffer will handle any
eol character formatting.
@param stc: EditraStyledTextCtrl
@param pos: current carat position
@param ichar: Indentation character
@return: string
"""
rtxt = u''
line = stc.GetCurrentLine()
text = stc.GetTextRange(stc.PositionFromLine(line), pos)
indent = stc.GetLineIndentation(line)
if ichar == u"\t":
tabw = stc.GetTabWidth()
else:
tabw = stc.GetIndent()
i_space = indent / tabw
ndent = u"\n" + ichar * i_space
rtxt = ndent + ((indent - (tabw * i_space)) * u' ')
def_pat = re.compile('\s*(class|def)\s+[a-zA-Z_][a-zA-Z0-9_]*')
text = text.strip()
if text.endswith('{') or def_pat.match(text):
rtxt += ichar
return rtxt
def AutoIndenter(stc, pos, ichar):
"""Auto indent Inno Setup Scripts. uses \n the text buffer will
handle any eol character formatting.
@param stc: EditraStyledTextCtrl
@param pos: current carat position
@param ichar: Indentation character
@return: string
"""
rtxt = u''
line = stc.GetCurrentLine()
text = stc.GetTextRange(stc.PositionFromLine(line), pos)
indent = stc.GetLineIndentation(line)
if ichar == u"\t":
tabw = stc.GetTabWidth()
else:
tabw = stc.GetIndent()
i_space = indent / tabw
ndent = u"\n" + ichar * i_space
rtxt = ndent + ((indent - (tabw * i_space)) * u' ')
if_pat = re.compile('if\s+.*\sthen')
text = text.strip()
if text == u'begin' or if_pat.match(text):
rtxt += ichar
return rtxt
def AutoIndenter(stc, pos, ichar):
"""Auto indent python code. uses \n the text buffer will
handle any eol character formatting.
@param stc: EditraStyledTextCtrl
@param pos: current carat position
@param ichar: Indentation character
@return: string
"""
rtxt = u''
line = stc.GetCurrentLine()
spos = stc.PositionFromLine(line)
text = stc.GetTextRange(spos, pos)
epos = stc.GetLineEndPosition(line)
inspace = text.isspace()
# Cursor is in the indent area somewhere
if inspace:
return u"\n" + text
# Check if the cursor is in column 0 and just return newline.
if not len(text):
return u"\n"
# Ignore empty lines and backtrace to find the previous line that we can
# get the indent position from
# while text.isspace():
# line -= 1
# if line < 0:
# return u''
# text = stc.GetTextRange(stc.PositionFromLine(line), pos)
indent = stc.GetLineIndentation(line)
if ichar == u"\t":
tabw = stc.GetTabWidth()
else:
tabw = stc.GetIndent()
i_space = indent / tabw
end_spaces = ((indent - (tabw * i_space)) * u" ")
tokens = filter(None, text.strip().split())
if tokens and not inspace:
if tokens[-1].endswith(u":"):
if tokens[0].rstrip(u":") in INDENT_KW:
i_space += 1
elif tokens[-1].endswith(u"\\"):
i_space += 1
elif tokens[0] in UNINDENT_KW:
i_space = max(i_space - 1, 0)
rval = u"\n" + (ichar * i_space) + end_spaces
if inspace and ichar != u"\t":
rpos = indent - (pos - spos)
if rpos < len(rval) and rpos > 0:
rval = rval[:-rpos]
elif rpos >= len(rval):
rval = u"\n"
return rval
def AutoIndenter(stc, pos, ichar):
"""Auto indent cpp code. uses \n the text buffer will
handle any eol character formatting.
@param stc: EditraStyledTextCtrl
@param pos: current carat position
@param ichar: Indentation character
@return: string
"""
rtxt = u''
line = stc.GetCurrentLine()
text = stc.GetTextRange(stc.PositionFromLine(line), pos)
indent = stc.GetLineIndentation(line)
if ichar == u"\t":
tabw = stc.GetTabWidth()
else:
tabw = stc.GetIndent()
i_space = indent / tabw
ndent = u"\n" + ichar * i_space
rtxt = ndent + ((indent - (tabw * i_space)) * u' ')
blks = '(program|function|subroutine|if|do|while)'
blk_pat = re.compile(blks + '\s*[(a-zA-Z][a-zA-Z0-9]*', re.IGNORECASE)
text = text.strip()
if text.endswith('{') or blk_pat.match(text) or text == 'else':
rtxt += ichar
return rtxt
def AutoIndenter(stc, pos, ichar):
"""Auto indent xtext code. uses \n the text buffer will
handle any eol character formatting.
This code is based on python AutoIndenter.
@param stc: EditraStyledTextCtrl
@param pos: current carat position
@param ichar: Indentation character
@return: string
"""
rtxt = u''
line = stc.GetCurrentLine()
spos = stc.PositionFromLine(line)
text = stc.GetTextRange(spos, pos)
inspace = text.isspace()
# Cursor is in the indent area somewhere or in the column 0.
if inspace or not len(text):
return u"\n" + text
text = text.strip()
if text.endswith(";"):
return u"\n"
indent = stc.GetLineIndentation(line)
if ichar == u"\t":
tabw = stc.GetTabWidth()
else:
tabw = stc.GetIndent()
i_space = indent / tabw
end_spaces = ((indent - (tabw * i_space)) * u" ")
if text.endswith(u":"):
i_space += 1
rval = u"\n" + ichar * i_space + end_spaces
return rval
def findIndent(self, stc, linenum):
"""Find proper indentation of the current Python source line.
This uses IDLE's python parsing routine to find the indent level of the
specified line based on the python code that comes before it.
@param linenum: line number
@return: integer indicating number of columns to indent.
"""
indentwidth = stc.GetIndent()
tabwidth = stc.GetTabWidth()
indent = stc.GetLineIndentation(linenum)
y = PyParse.Parser(indentwidth, tabwidth)
# FIXME: context line hack straight from IDLE
for context in [50, 500, 5000000]:
firstline = linenum - context
if firstline < 0:
firstline = 0
start = stc.PositionFromLine(firstline)
# end is the position before the first character of the line, so
# we're looking at the code up to the start of the current line.
end = stc.PositionFromLine(linenum)
rawtext = stc.GetTextRange(start, end)
# Handle two issues with this loop. 1: Remove comments that start
# at column zero so they don't affect the indenting. 2: PyParse
# is hardcoded for "\n" style newlines only, so by splitting the
# lines here we can change whatever the newlines are into "\n"
# characters.
lines = []
for line in rawtext.splitlines():
if len(line) > 0:
if line[0] != '#':
lines.append(line)
lines.append('') # include a blank line at the end
rawtext = "\n".join(lines)
y.set_str(rawtext)
bod = y.find_good_parse_start(build_char_in_string_func(
stc, start))
if bod is not None or firstline == 0:
break
#dprint(rawtext)
self.dprint("bod = %s" % bod)
y.set_lo(bod or 0)
c = y.get_continuation_type()
self.dprint("continuation type: %s" % c)
extra_data = None
if c != PyParse.C_NONE:
# The current stmt hasn't ended yet.
if c == PyParse.C_STRING_FIRST_LINE:
s = stc.GetStyleAt(end)
if s == 6 or s == 7:
# Inside a triple quoted string (TQS)
self.dprint("C_STRING_FIRST_LINE in TQS")
indentstr = y.get_base_indent_string()
indent = len(indentstr.expandtabs(tabwidth))
else:
# after the first line of a string; do not indent at all
self.dprint("C_STRING_FIRST_LINE")
pass
elif c == PyParse.C_STRING_NEXT_LINES:
# inside a string which started before this line;
# just mimic the current indent
#text.insert("insert", indent)
s = stc.GetStyleAt(end)
if s == 6 or s == 7:
# Inside a triple quoted string (TQS)
self.dprint("C_STRING_NEXT_LINES in TQS")
indentstr = y.get_base_indent_string()
indent = len(indentstr.expandtabs(tabwidth))
else:
# FIXME: Does this ever happen without being in a TQS???
self.dprint("C_STRING_NEXT_LINES")
elif c == PyParse.C_BRACKET:
# line up with the first (if any) element of the
# last open bracket structure; else indent one
# level beyond the indent of the line with the
# last open bracket
self.dprint("C_BRACKET")
#self.reindent_to(y.compute_bracket_indent())
indent = y.compute_bracket_indent()
elif c == PyParse.C_BACKSLASH:
# if more than one line in this stmt already, just
# mimic the current indent; else if initial line
# has a start on an assignment stmt, indent to
# beyond leftmost =; else to beyond first chunk of
# non-whitespace on initial line
if y.get_num_lines_in_stmt() > 1:
pass
else:
indent = y.compute_backslash_indent()
else:
assert 0, "bogus continuation type %r" % (c, )
else:
# This line starts a brand new stmt; indent relative to
# indentation of initial line of closest preceding
# interesting stmt.
indentstr = y.get_base_indent_string()
indent = len(indentstr.expandtabs(tabwidth))
if y.is_block_opener():
self.dprint("block opener")
indent += indentwidth
extra_data = "block opener"
elif indent and y.is_block_closer():
self.dprint("block dedent")
indent = ((indent - 1) // indentwidth) * indentwidth
extra_data = "block dedent"
self.dprint("indent = %d" % indent)
# check some special cases to see if they line should be dedented by
# a level
before = stc.GetLineIndentPosition(linenum)
style = stc.GetStyleAt(before)
end = stc.GetLineEndPosition(linenum)
cmd = stc.GetTextRange(before, end)
#dprint("checking %s" % cmd)
if linenum > 0 and style == wx.stc.STC_P_WORD and (
cmd.startswith('else') or cmd.startswith('elif')
or cmd.startswith('except') or cmd.startswith('finally')):
self.dprint("Found a dedent: %s" % cmd)
if extra_data != "block dedent":
# If we aren't right after a return or something that already
# caused a dedent, dedent it
indent -= indentwidth
return indent
