#----------------------------------------------------------------------------- # Name: StyledTextCtrls.py # Purpose: Mixin classes to extend wxStyledTextCtrl # # Author: Riaan Booysen # # Created: 2000/04/26 # RCS-ID: $Id: StyledTextCtrls.py,v 1.32 2004/08/16 13:35:58 riaan Exp $ # Copyright: (c) 1999 - 2004 Riaan Booysen # Licence: GPL #----------------------------------------------------------------------------- import os, re, keyword, string from wxPython.wx import * from wxPython.stc import * eols = { wxSTC_EOL_CRLF : '\r\n', wxSTC_EOL_CR : '\r', wxSTC_EOL_LF : '\n'} import Preferences import methodparse import STCStyleEditor # from PythonWin from IDLE :) _is_block_opener = re.compile(r':\s*(#.*)?$').search _is_block_closer = re.compile(r''' \s* ( return | break | continue | raise | pass ) \b ''', re.VERBOSE).match def ver_tot(ma, mi, re): return ma*10000+mi*100+re word_delim = string.letters + string.digits + '_' object_delim = word_delim + '.' #---Utility mixins-------------------------------------------------------------- class FoldingStyledTextCtrlMix: def __init__(self, wId, margin): self.__fold_margin = margin if Preferences.edSTCFolding: self.SetProperty('fold', '1') self.SetMarginType(margin, wxSTC_MARGIN_SYMBOL) self.SetMarginMask(margin, wxSTC_MASK_FOLDERS) self.SetMarginSensitive(margin, true) self.SetMarginWidth(margin, Preferences.STCFoldingMarginWidth) markIdnt, markBorder, markCenter = Preferences.STCFoldingClose self.MarkerDefine(wxSTC_MARKNUM_FOLDER, markIdnt, markBorder, markCenter) self.MarkerDefine(wxSTC_MARKNUM_FOLDEREND, wxSTC_MARK_EMPTY, markBorder, markCenter) markIdnt, markBorder, markCenter = Preferences.STCFoldingOpen self.MarkerDefine(wxSTC_MARKNUM_FOLDEROPEN, markIdnt, markBorder, markCenter) self.MarkerDefine(wxSTC_MARKNUM_FOLDEROPENMID, wxSTC_MARK_EMPTY, markBorder, markCenter) try: wxSTC_MARK_BACKGROUND except: pass else: self.MarkerDefine(wxSTC_MARKNUM_FOLDERMIDTAIL, wxSTC_MARK_BACKGROUND, "white", "black") self.MarkerDefine(wxSTC_MARKNUM_FOLDERSUB, wxSTC_MARK_BACKGROUND, "white", "black") self.MarkerDefine(wxSTC_MARKNUM_FOLDERTAIL, wxSTC_MARK_BACKGROUND, "white", "black") def OnMarginClick(self, evt): # fold and unfold as needed if evt.GetMargin() == self.__fold_margin: if evt.GetShift() and evt.GetControl(): self.FoldAll() else: lineClicked = self.LineFromPosition(evt.GetPosition()) if self.GetFoldLevel(lineClicked) & wxSTC_FOLDLEVELHEADERFLAG: if evt.GetShift(): self.SetFoldExpanded(lineClicked, true) self.Expand(lineClicked, true, true, 1) elif evt.GetControl(): if self.GetFoldExpanded(lineClicked): self.SetFoldExpanded(lineClicked, false) self.Expand(lineClicked, false, true, 0) else: self.SetFoldExpanded(lineClicked, true) self.Expand(lineClicked, true, true, 100) else: self.ToggleFold(lineClicked) def FoldAll(self): lineCount = self.GetLineCount() expanding = true # find out if we are folding or unfolding for lineNum in range(lineCount): if self.GetFoldLevel(lineNum) & wxSTC_FOLDLEVELHEADERFLAG: expanding = not self.GetFoldExpanded(lineNum) break lineNum = 0 while lineNum < lineCount: level = self.GetFoldLevel(lineNum) if level & wxSTC_FOLDLEVELHEADERFLAG and \ (level & wxSTC_FOLDLEVELNUMBERMASK) == wxSTC_FOLDLEVELBASE: if expanding: self.SetFoldExpanded(lineNum, true) lineNum = self.Expand(lineNum, true) lineNum = lineNum - 1 else: lastChild = self.GetLastChild(lineNum, -1) self.SetFoldExpanded(lineNum, false) if lastChild > lineNum: self.HideLines(lineNum+1, lastChild) lineNum = lineNum + 1 def Expand(self, line, doExpand, force=false, visLevels=0, level=-1): lastChild = self.GetLastChild(line, level) line = line + 1 while line <= lastChild: if force: if visLevels > 0: self.ShowLines(line, line) else: self.HideLines(line, line) else: if doExpand: self.ShowLines(line, line) if level == -1: level = self.GetFoldLevel(line) if level & wxSTC_FOLDLEVELHEADERFLAG: if force: if visLevels > 1: self.SetFoldExpanded(line, true) else: self.SetFoldExpanded(line, false) line = self.Expand(line, doExpand, force, visLevels-1) else: if doExpand and self.GetFoldExpanded(line): line = self.Expand(line, true, force, visLevels-1) else: line = self.Expand(line, false, force, visLevels-1) else: line = line + 1; return line def idWord(line, piv, lineStart, leftDelim=word_delim, rightDelim=word_delim): if piv >= len(line): return 0, 0 pivL = pivR = piv # Look left for pivL in range(piv, -1, -1): if not line[pivL] in leftDelim: pivL = pivL + 1 break # Look right for pivR in range(piv + 1, len(line)): if not line[pivR] in rightDelim: break else: pivR = pivR+1 return pivL + lineStart, pivR - pivL class BrowseStyledTextCtrlMix: """ This class is to be mix-in with a wxStyledTextCtrl to add functionality for browsing the code. """ def __init__(self, indicator=0): self.handCrs = 1 self.stndCrs = 0 self.IndicatorSetStyle(indicator, wxSTC_INDIC_PLAIN) self.IndicatorSetForeground(indicator, wxBLUE) self._indicator = indicator self.styleStart = 0 self.styleLength = 0 self.ctrlDown = false EVT_MOTION(self, self.OnBrowseMotion) EVT_LEFT_DOWN(self, self.OnBrowseClick) EVT_KEY_DOWN(self, self.OnKeyDown) EVT_KEY_UP(self, self.OnKeyUp) def doClearBrwsLn(self): self.styleStart, self.styleLength = \ self.clearUnderline(self.styleStart, self.styleLength) def BrowseClick(self, word, line, lineNo, start, style): """Called when a link is clicked. Override to use, return true if click is swallowed """ return false def StyleVeto(self, style): return false # XXX Setting the cursor irrevocably changes the cursor for the whole STC def underlineWord(self, start, length): #self.SetCursor(self.handCrs) self.SetLexer(wxSTC_LEX_NULL) self.StartStyling(start, wxSTC_INDICS_MASK) self.SetStyling(length, wxSTC_INDIC0_MASK) return start, length def clearUnderline(self, start, length): #self.SetCursor(self.stndCrs) self.StartStyling(start, wxSTC_INDICS_MASK) self.SetStyling(length, 0) self.SetLexer(wxSTC_LEX_PYTHON) self.Refresh(false) return 0, 0 def getBrowsableText(self, line, piv, lnStPs): return idWord(line, piv, lnStPs) def OnBrowseMotion(self, event): event.Skip() #check if words should be underlined if event.ControlDown(): mp = event.GetPosition() pos = self.PositionFromPoint(wxPoint(mp.x, mp.y)) stl = self.GetStyleAt(pos) & 31 if self.StyleVeto(stl): if self.styleLength > 0: self.styleStart, self.styleLength = \ self.clearUnderline(self.styleStart, self.styleLength) return lnNo = self.LineFromPosition(pos) lnStPs = self.PositionFromLine(lnNo) line = self.GetLine(lnNo) piv = pos - lnStPs start, length = self.getBrowsableText(line, piv, lnStPs) #mark new if length > 0 and self.styleStart != start: if self.styleLength > 0: self.clearUnderline(self.styleStart, self.styleLength) self.styleStart,self.styleLength = \ self.underlineWord(start, length) #keep current elif self.styleStart == start: pass #delete previous elif self.styleLength > 0: self.styleStart, self.styleLength = \ self.clearUnderline(self.styleStart, self.styleLength) #clear any underlined words elif self.styleLength > 0: self.styleStart, self.styleLength = \ self.clearUnderline(self.styleStart, self.styleLength) def getStyledWordElems(self, styleStart, styleLength): if styleLength > 0: lnNo = self.LineFromPosition(styleStart) lnStPs = self.PositionFromLine(lnNo) line = self.GetLine(lnNo) start = styleStart - lnStPs word = line[start:start+styleLength] return word, line, lnNo, start else: return '', 0, 0, 0 def OnBrowseClick(self, event): word, line, lnNo, start = self.getStyledWordElems(self.styleStart, self.styleLength) if word: style = self.GetStyleAt(self.styleStart) & 31 if self.BrowseClick(word, line, lnNo, start, style): return event.Skip() def OnKeyDown(self, event): if event.ControlDown(): self.ctrlDown = true event.Skip() def OnKeyUp(self, event): if self.ctrlDown and (not event.ControlDown()): self.ctrlDown = false if self.styleLength > 0: self.styleStart, self.styleLength = \ self.clearUnderline(self.styleStart, self.styleLength) event.Skip() class CodeHelpStyledTextCtrlMix: def getCurrLineInfo(self): pos = self.GetCurrentPos() lnNo = self.GetCurrentLine() lnStPs = self.PositionFromLine(lnNo) return (pos, lnNo, lnStPs, self.GetCurLine()[0], pos - lnStPs - 1) def getFirstContinousBlock(self, docs): res = [] for line in docs.split('\n'): if line.strip(): res.append(line) else: break return '\n'.join(res) class AutoCompleteCodeHelpSTCMix(CodeHelpStyledTextCtrlMix): """ Mixin that assists with code completion Users should implement: def getCodeCompOptions(self, word, rootWord, matchWord, lnNo): return ['list', 'of', 'options'] """ def __init__(self): self.AutoCompSetIgnoreCase(true) self.AutoCompSetCancelAtStart(false) def codeCompCheck(self): pos, lnNo, lnStPs, line, piv = self.getCurrLineInfo() start, length = idWord(line, piv, lnStPs, object_delim, object_delim) startLine = start-lnStPs word = line[startLine:startLine+length] pivword = piv - startLine dot = word.rfind('.', 0, pivword+1) matchWord = word if dot != -1: rdot = word.find('.', pivword) if rdot != -1: matchWord = word[dot+1:rdot] else: matchWord = word[dot+1:] offset = pivword - dot rootWord = word[:dot] else: offset = pivword + 1 rootWord = '' if not matchWord: offset = 0 names = self.getCodeCompOptions(word, rootWord, matchWord, lnNo) # remove duplicates and sort unqNms = {} for name in names: unqNms[name] = None names = unqNms.keys() #sortnames = map(None, map(string.lower, names), names) sortnames = [(name.lower(), name) for name in names] sortnames.sort() #names = map(lambda n: n[1], sortnames) names = [n[1] for n in sortnames] # move _* names to the end of the list cnt = 0 maxmoves = len(names) while cnt < maxmoves: if names[0] and names[0][0] == '_': names.append(names[0]) del names[0] cnt = cnt + 1 else: break self.AutoCompShow(offset, ' '.join(names)) #self.AutoCompSelect(matchWord) class CallTipCodeHelpSTCMix(CodeHelpStyledTextCtrlMix): """ Mixin that assists with code completion Users should implement: def getTipValue(word, lnNo): return 'Tip' """ def __init__(self): self.lastCallTip = '' self.lastTipHilite = (0, 0) self.CallTipSetBackground(Preferences.STCCallTipBackColour) def getTipValue(self, word, lnNo): return '' def callTipCheck(self): pos, lnNo, lnStPs, line, piv = self.getCurrLineInfo() bracket = methodparse.matchbracket(line[:piv+1], '(') if bracket == -1 and self.CallTipActive(): self.CallTipCancel() return cursBrktOffset = piv - bracket start, length = idWord(line, bracket-1, lnStPs, object_delim, object_delim) startLine = start-lnStPs word = line[startLine:startLine+length] if word: tip = self.getTipValue(word, lnNo) if tip: # Minus offset of 1st bracket in the tip tipBrkt = tip.find('(') if tipBrkt != -1: pos = pos - tipBrkt - 1 else: tipBrkt = 0 # get the current parameter from source paramNo = len(methodparse.safesplitfields(\ line[bracket+1:piv+1]+'X', ',')) if paramNo: paramNo = paramNo - 1 # get hilight & corresponding parameter from tip tipBrktEnd = tip.rfind(')') tip_param_str = tip[tipBrkt+1:tipBrktEnd] tip_params = methodparse.safesplitfields(\ tip_param_str, ',', ('(', '{'), (')', '}') ) try: hiliteStart = tipBrkt+1 + tip_param_str.find(tip_params[paramNo]) except IndexError: hilite = (0, 0) else: hilite = (hiliteStart, hiliteStart+len(tip_params[paramNo])) # don't update if active and unchanged if self.CallTipActive() and tip == self.lastCallTip and \ hilite == self.lastTipHilite: return # close if active and changed if self.CallTipActive() and (tip != self.lastCallTip or \ hilite != self.lastTipHilite): self.CallTipCancel() self.CallTipShow(pos - cursBrktOffset, tip) self.CallTipSetHighlight(hilite[0], hilite[1]) self.lastCallTip = tip self.lastTipHilite = hilite class DebuggingViewSTCMix: def __init__(self, debugMarkers): (self.brkPtMrk, self.tmpBrkPtMrk, self.disabledBrkPtMrk, self.stepPosMrk) = debugMarkers # XXX properly allocate the marker self.stepPosBackMrk = self.stepPosMrk + 1 # Initialize breakpoints from file and running debugger # XXX Remote breakpoints should be stored in a local pickle filename = self.model.filename from Debugger.Breakpoint import bplist self.breaks = bplist.getFileBreakpoints(filename) self.tryLoadBreakpoints() def setupDebuggingMargin(self, symbolMrg): self.SetMarginType(symbolMrg, wxSTC_MARGIN_SYMBOL) self.SetMarginWidth(symbolMrg, Preferences.STCSymbolMarginWidth) self.SetMarginSensitive(symbolMrg, true) markIdnt, markBorder, markCenter = Preferences.STCBreakpointMarker self.MarkerDefine(self.brkPtMrk, markIdnt, markBorder, markCenter) markIdnt, markBorder, markCenter = Preferences.STCLinePointer self.MarkerDefine(self.stepPosMrk, markIdnt, markBorder, markCenter) markIdnt, markBorder, markCenter = Preferences.STCTmpBreakpointMarker self.MarkerDefine(self.tmpBrkPtMrk, markIdnt, markBorder, markCenter) markIdnt, markBorder, markCenter = Preferences.STCDisabledBreakpointMarker self.MarkerDefine(self.disabledBrkPtMrk, markIdnt, markBorder, markCenter) try: wxSTC_MARK_BACKGROUND except: self.MarkerDefine(self.stepPosBackMrk, wxSTC_MARK_EMPTY, wxColour(255, 255, 255), wxColour(128, 128, 255)) else: self.MarkerDefine(self.stepPosBackMrk, wxSTC_MARK_BACKGROUND, wxColour(255, 255, 255), wxColour(220, 220, 255)) def setInitialBreakpoints(self): # Adds markers where the breakpoints are located. for mrk in (self.tmpBrkPtMrk, self.disabledBrkPtMrk, self.brkPtMrk): self.MarkerDeleteAll(mrk) for brk in self.breaks.listBreakpoints(): self.setBreakMarker(brk) def setBreakMarker(self, brk): if brk['temporary']: mrk = self.tmpBrkPtMrk elif not brk['enabled']: mrk = self.disabledBrkPtMrk else: mrk = self.brkPtMrk lineno = brk['lineno'] - 1 currMrk = self.MarkerGet(lineno) & (1 << mrk) if currMrk: self.MarkerDelete(lineno, mrk) self.MarkerAdd(lineno, mrk) def deleteBreakMarkers(self, lineNo): self.MarkerDelete(lineNo - 1, self.brkPtMrk) self.MarkerDelete(lineNo - 1, self.tmpBrkPtMrk) self.MarkerDelete(lineNo - 1, self.disabledBrkPtMrk) def deleteBreakPoint(self, lineNo): self.breaks.deleteBreakpoints(lineNo) debugger = self.model.editor.debugger if debugger: # Try to apply to the running debugger. debugger.deleteBreakpoints(self.model.filename, lineNo) self.deleteBreakMarkers(lineNo) def addBreakPoint(self, lineNo, temp=0, notify_debugger=1): filename = self.model.filename self.breaks.addBreakpoint(lineNo, temp) if notify_debugger: debugger = self.model.editor.debugger if debugger: # Try to apply to the running debugger. debugger.setBreakpoint(filename, lineNo, temp) if temp: mrk = self.tmpBrkPtMrk else: mrk = self.brkPtMrk self.MarkerAdd(lineNo - 1, mrk) def moveBreakpoint(self, bpt, delta): # remove index = (bpt.file, bpt.line) if index not in bpt.bplist.keys(): return bpt.bplist[index].remove(bpt) if not bpt.bplist[index]: del bpt.bplist[index] del self.breaks[bpt.line] bpt.line = bpt.line + delta # re-add index = (bpt.file, bpt.line) if bpt.bplist.has_key(index): bpt.bplist[index].append(bpt) else: bpt.bplist[index] = [bpt] self.breaks[bpt.line] = bpt def tryLoadBreakpoints(self): import pickle fn = self.getBreakpointFilename() if fn: rval = self.breaks.loadBreakpoints(fn) if rval: self.setInitialBreakpoints() else: rval = None return rval def saveBreakpoints(self): # XXX This is not yet called automatically on saving a module, # should it be ? fn = self.getBreakpointFilename() if fn: self.breaks.saveBreakpoints(fn) def clearStepPos(self, lineNo): if lineNo < 0: lineNo = 0 self.MarkerDelete(lineNo, self.stepPosMrk) self.MarkerDelete(lineNo, self.stepPosBackMrk) def setStepPos(self, lineNo): if lineNo < 0: lineNo = 0 self.MarkerDeleteAll(self.stepPosMrk) self.MarkerAdd(lineNo, self.stepPosMrk) self.MarkerDeleteAll(self.stepPosBackMrk) self.MarkerAdd(lineNo, self.stepPosBackMrk) if self.breaks.hasBreakpoint(lineNo + 1): # Be sure all the breakpoints for this file are displayed. self.setInitialBreakpoints() self.MarkerDelete(lineNo, self.tmpBrkPtMrk) def getBreakpointFilename(self): try: return os.path.splitext(self.model.assertLocalFile())[0]+'.brk' except AssertionError: return '' def adjustBreakpoints(self, linesAdded, modType, evtPos): line = self.LineFromPosition(evtPos)#event.GetPosition()) endline = self.GetLineCount() if self.breaks.hasBreakpoint( min(line, endline), max(line, endline)): changed = self.breaks.adjustBreakpoints(line, linesAdded) debugger = self.model.editor.debugger if debugger: # XXX also check that module has been imported # XXX this should apply; with or without breakpoint if debugger.running and \ not modType & wxSTC_PERFORMED_UNDO: wxLogWarning('Adding or removing lines from the ' 'debugger will cause the source and the ' 'debugger to be out of sync.' '\nPlease undo this action.') debugger.adjustBreakpoints(self.model.filename, line, linesAdded) else: # bdb must still be updated import bdb bpList = bdb.Breakpoint.bplist filename = self.model.filename #canonic form, same as url form I think setBreaks = [] # store reference and remove from (fn, ln) refed dict. for bpFile, bpLine in bpList.keys(): if bpFile == filename and bpLine > line: setBreaks.append(bpList[bpFile, bpLine]) del bpList[bpFile, bpLine] # put old break at new place and renumber for brks in setBreaks: for brk in brks: brk.line = brk.line + linesAdded # merge in moved breaks if bpList.has_key((filename, brk.line)): bpList[filename, brk.line].append(brk) else: bplist[filename, brk.line] = [brk] def OnSaveBreakPoints(self, event): self.saveBreakpoints() def OnLoadBreakPoints(self, event): self.tryLoadBreakpoints() def OnSetBreakPoint(self, event): line = self.LineFromPosition(self.GetCurrentPos()) + 1 if self.breaks.hasBreakpoint(line): self.deleteBreakPoint(line) else: self.addBreakPoint(line) def OnMarginClick(self, event): lineClicked = self.LineFromPosition(event.GetPosition()) + 1 if self.breaks.hasBreakpoint(lineClicked): self.deleteBreakPoint(lineClicked) else: self.addBreakPoint(lineClicked) #---Language mixins------------------------------------------------------------- class LanguageSTCMix: def __init__(self, wId, marginNumWidth, language, config): self.language = language (cfg, self.commonDefs, self.styleIdNames, self.styles, psgn, psg, olsgn, olsg, ds, self.lexer, self.keywords, bi) = \ self.getSTCStyles(config, language) #self.SetEOLMode(wxSTC_EOL_LF) #self.eol = '\n' self.SetBufferedDraw(Preferences.STCBufferedDraw) self.SetCaretPeriod(Preferences.STCCaretPeriod) self.SetViewWhiteSpace(Preferences.STCViewWhiteSpace) self.SetViewEOL(Preferences.STCViewEOL) self.SetIndent(Preferences.STCIndent) self.SetUseTabs(Preferences.STCUseTabs) self.SetTabWidth(Preferences.STCTabWidth) self.SetCaretPeriod(Preferences.STCCaretPeriod) #if Preferences.STCCaretPolicy: # self.SetCaretPolicy(Preferences.STCCaretPolicy, # Preferences.STCCaretPolicySlop) self.SetEdgeMode(Preferences.STCEdgeMode) self.SetEdgeColumn(Preferences.STCEdgeColumnWidth) if marginNumWidth: self.SetMargins(1, 1) self.SetMarginType(marginNumWidth[0], wxSTC_MARGIN_NUMBER) self.SetMarginWidth(marginNumWidth[0], marginNumWidth[1]) EVT_STC_UPDATEUI(self, wId, self.OnUpdateUI) def setStyles(self, commonOverride=None): commonDefs = {} commonDefs.update(self.commonDefs) if commonOverride is not None: commonDefs.update(commonOverride) STCStyleEditor.setSTCStyles(self, self.styles, self.styleIdNames, commonDefs, self.language, self.lexer, self.keywords) def getSTCStyles(self, config, language): """ Override to set values directly """ return STCStyleEditor.initFromConfig(config, language) keymap={'euro': {226: chr(124), 69: chr(128), 81: chr(64), 77: chr(181), 48: chr(125), 337: chr(126), 50: chr(178), 51: chr(179), 55: chr(123), 56: chr(91), 57: chr(93), 219: chr(92), }, 'swiss-german': {192: chr(93), 226: chr(92), 50: chr(64), 51: chr(35), 55: chr(124), 186: chr(91), 219: chr(96), 220: chr(123), 221: chr(126), 223: chr(125), }, 'italian': {192: chr(64), 337: chr(93), 186: chr(91), 219: chr(123), 221: chr(125), 222: chr(35), }, 'france': {226: chr(54), 48: chr(64), 337: chr(125), 50: chr(126), 51: chr(35), 52: chr(123), 53: chr(91), 54: chr(124), 55: chr(96), 56: chr(92), 219: chr(93), }, } def handleSpecialEuropeanKeys(self, event, countryKeymap='euro'): key = event.KeyCode() keymap = self.keymap[countryKeymap] if event.AltDown() and event.ControlDown() and keymap.has_key(key): currPos = self.GetCurrentPos() self.InsertText(currPos, keymap[key]) self.SetCurrentPos(self.GetCurrentPos()+1) self.SetSelectionStart(self.GetCurrentPos()) stcConfigPath = os.path.join(Preferences.rcPath, 'stc-styles.rc.cfg') class PythonStyledTextCtrlMix(LanguageSTCMix): def __init__(self, wId, margin): LanguageSTCMix.__init__(self, wId, margin, 'python', stcConfigPath) self.keywords = self.keywords + ' yield None' try: True except NameError: self.keywords = self.keywords + ' true false' else: self.keywords = self.keywords + ' True False' self.setStyles() def grayout(self, do): if not Preferences.grayoutSource: return if do: f = {'backcol': '#EEF2FF'} else: f = None self.setStyles(f) def OnUpdateUI(self, event): # check for matching braces braceAtCaret = -1 braceOpposite = -1 charBefore = None caretPos = self.GetCurrentPos() if caretPos > 0: try: charBefore = chr(self.GetCharAt(caretPos - 1)) except ValueError: charBefore = '' styleBefore = self.GetStyleAt(caretPos - 1) # check before if charBefore and charBefore in "[]{}()" and styleBefore == 10: braceAtCaret = caretPos - 1 # check after if braceAtCaret < 0: try: charAfter = chr(self.GetCharAt(caretPos)) except ValueError: charAfter = '' styleAfter = self.GetStyleAt(caretPos) if charAfter and charAfter in "[]{}()" and styleAfter == 10: braceAtCaret = caretPos if braceAtCaret >= 0: braceOpposite = self.BraceMatch(braceAtCaret) if braceAtCaret != -1 and braceOpposite == -1: self.BraceBadLight(braceAtCaret) else: self.BraceHighlight(braceAtCaret, braceOpposite) # self.Refresh(false) def doAutoIndent(self, prevline, pos): stripprevline = prevline.strip() if stripprevline: indent = prevline[:prevline.find(stripprevline)] else: try: indent = prevline.strip('\r\n', 1) except TypeError: indent = prevline while indent and indent[-1] in ('\r', '\n'): indent = indent[:-1] if self.GetUseTabs(): indtBlock = '\t' else: # XXX Why did I do this? indtBlock = self.GetTabWidth()*' ' if _is_block_opener(prevline): indent = indent + indtBlock elif _is_block_closer(prevline): indent = indent[:-1*len(indtBlock)] self.BeginUndoAction() try: self.InsertText(pos, indent) self.GotoPos(pos + len(indent)) finally: self.EndUndoAction() class TextSTCMix(LanguageSTCMix): def __init__(self, wId): LanguageSTCMix.__init__(self, wId, (), 'text', stcConfigPath) self.setStyles() ## 1 : ## 2 : diff ## 3 : +++/--- ## 4 : @ ## 5 : - ## 6 : + class DiffSTCMix(LanguageSTCMix): def __init__(self, wId): LanguageSTCMix.__init__(self, wId, (), 'diff', stcConfigPath) self.setStyles() from types import IntType, SliceType, StringType class STCLinesList: def __init__(self, STC): self.__STC = STC def _rememberPos(self): self.__pos = self.GetCurrentPos() def __getitem__(self, key): if type(key) is IntType: # XXX last char is garbage if key < len(self): return self.__STC.GetLine(key) else: raise IndexError elif type(key) is SliceType: res = [] for idx in range(key.start, key.stop): res.append(self[idx]) return res else: raise TypeError, '%s not supported' % `type(key)` def __setitem__(self, key, value): stc = self.__STC if type(key) is IntType: assert type(value) is StringType if key < len(self): stc.SetSelection(stc.PositionFromLine(key), stc.GetLineEndPosition(key)) stc.ReplaceSelection(value) else: raise IndexError elif type(key) is SliceType: lines = eols[stc.GetEOLMode()].join(value) stc.SetSelection(stc.PositionFromLine(key.start), stc.GetLineEndPosition(key.stop)) stc.ReplaceSelection(lines) else: raise TypeError, '%s not supported' % `type(key)` def __delitem__(self, key): stc = self.__STC if type(key) is IntType: stc.SetSelection(stc.PositionFromLine(key), stc.GetLineEndPosition(key)+1) stc.ReplaceSelection('') elif type(key) is SliceType: stc.SetSelection(stc.PositionFromLine(key.start), stc.GetLineEndPosition(key.stop)+1) stc.ReplaceSelection('') else: raise TypeError, '%s not supported' % `type(key)` def __getattr__(self, name): if name == 'current': return self.__STC.GetCurrentLine() if name == 'count': return self.__STC.GetLineCount() if name == 'size': return self.__STC.GetTextLength() # dubious if name == 'line': return self.__STC.GetCurLine()[0] # dubious if name == 'pos': return self.__STC.GetCurrentPos() raise AttributeError, name def __len__(self): return self.__STC.GetLineCount()