beremiz: comparison editors/TextViewer.py

equal deleted inserted replaced

-:eb2aa27602b7
+:48f5f2a622c8
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
 #based on the plcopen standard.
 #
 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
 #
 #See COPYING file for copyrights details.
 #
 LETTERS = ['_']
 for i in xrange(26):
 LETTERS.append(chr(ord('a') + i))
 LETTERS.append(chr(ord('A') + i))
 [STC_PLC_WORD, STC_PLC_COMMENT, STC_PLC_NUMBER, STC_PLC_STRING,
 STC_PLC_VARIABLE, STC_PLC_PARAMETER, STC_PLC_FUNCTION, STC_PLC_JUMP,
 STC_PLC_ERROR, STC_PLC_SEARCH_RESULT] = range(10)
 [SPACE, WORD, NUMBER, STRING, WSTRING, COMMENT, PRAGMA, DPRAGMA] = range(8)
 [ID_TEXTVIEWER, ID_TEXTVIEWERTEXTCTRL,
 ] = [wx.NewId() for _init_ctrls in range(2)]
 def LineStartswith(line, symbols):
 return reduce(lambda x, y: x or y, map(lambda x: line.startswith(x), symbols), False)
 class TextViewer(EditorPanel):
 ID = ID_TEXTVIEWER
 if wx.VERSION < (2, 6, 0):
 def Bind(self, event, function, id = None):
 if id is not None:
 event(self, id, function)
 else:
 event(self, function)
 def _init_Editor(self, prnt):
 self.Editor = CustomStyledTextCtrl(id=ID_TEXTVIEWERTEXTCTRL,
 parent=prnt, name="TextViewer", size=wx.Size(0, 0), style=0)
 self.Editor.ParentWindow = self
 self.Editor.CmdKeyAssign(ord('+'), wx.stc.STC_SCMOD_CTRL, wx.stc.STC_CMD_ZOOMIN)
 self.Editor.CmdKeyAssign(ord('-'), wx.stc.STC_SCMOD_CTRL, wx.stc.STC_CMD_ZOOMOUT)
 self.Editor.SetViewWhiteSpace(False)
 self.Editor.SetLexer(wx.stc.STC_LEX_CONTAINER)
 # Global default styles for all languages
 self.Editor.StyleSetSpec(wx.stc.STC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)
 self.Editor.StyleClearAll()  # Reset all to be like the default
 self.Editor.StyleSetSpec(wx.stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,size:%(size)d" % faces)
 self.Editor.SetSelBackground(1, "#E0E0E0")
 # Highlighting styles
 self.Editor.StyleSetSpec(STC_PLC_WORD, "fore:#00007F,bold,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_VARIABLE, "fore:#7F0000,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_PARAMETER, "fore:#7F007F,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_FUNCTION, "fore:#7F7F00,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_NUMBER, "fore:#007F7F,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_STRING, "fore:#007F00,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_JUMP, "fore:#FF7FFF,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_ERROR, "fore:#FF0000,back:#FFFF00,size:%(size)d" % faces)
 self.Editor.StyleSetSpec(STC_PLC_SEARCH_RESULT, "fore:#FFFFFF,back:#FFA500,size:%(size)d" % faces)
 # Indicators styles
 self.Editor.IndicatorSetStyle(0, wx.stc.STC_INDIC_SQUIGGLE)
 if self.ParentWindow is not None and self.Controler is not None:
 self.Editor.IndicatorSetForeground(0, wx.RED)
 else:
 self.Editor.IndicatorSetForeground(0, wx.WHITE)
 # Line numbers in the margin
 self.Editor.SetMarginType(1, wx.stc.STC_MARGIN_NUMBER)
 self.Editor.SetMarginWidth(1, 50)
 # Folding
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDEROPEN,    wx.stc.STC_MARK_BOXMINUS,          "white", "#808080")
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDER,        wx.stc.STC_MARK_BOXPLUS,           "white", "#808080")
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDERSUB,     wx.stc.STC_MARK_VLINE,             "white", "#808080")
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDERTAIL,    wx.stc.STC_MARK_LCORNER,           "white", "#808080")
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDEREND,     wx.stc.STC_MARK_BOXPLUSCONNECTED,  "white", "#808080")
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDEROPENMID, wx.stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
 self.Editor.MarkerDefine(wx.stc.STC_MARKNUM_FOLDERMIDTAIL, wx.stc.STC_MARK_TCORNER,           "white", "#808080")
 # Indentation size
 self.Editor.SetTabWidth(2)
 self.Editor.SetUseTabs(0)
 self.Editor.SetModEventMask(wx.stc.STC_MOD_BEFOREINSERT|
 wx.stc.STC_MOD_BEFOREDELETE|
 wx.stc.STC_PERFORMED_USER)
 self.Bind(wx.stc.EVT_STC_STYLENEEDED, self.OnStyleNeeded, id=ID_TEXTVIEWERTEXTCTRL)
 self.Editor.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
 if self.Controler is not None:
 self.Editor.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
 self.Bind(wx.stc.EVT_STC_DO_DROP, self.OnDoDrop, id=ID_TEXTVIEWERTEXTCTRL)
 self.Bind(wx.stc.EVT_STC_MODIFIED, self.OnModification, id=ID_TEXTVIEWERTEXTCTRL)
 def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):
 if tagname != "" and controler is not None:
 self.VARIABLE_PANEL_TYPE = controler.GetPouType(tagname.split("::")[1])
 EditorPanel.__init__(self, parent, tagname, window, controler, debug)
 self.Keywords = []
 self.Variables = {}
 self.Functions = {}
 self.TypeNames = []
 self.Jumps = []
 self.EnumeratedValues = []
 self.DisableEvents = True
 self.TextSyntax = None
 self.CurrentAction = None
 self.InstancePath = instancepath
 self.ContextStack = []
 self.CallStack = []
 self.ResetSearchResults()
 self.RefreshHighlightsTimer = wx.Timer(self, -1)
 self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)
 def __del__(self):
 self.RefreshHighlightsTimer.Stop()
 def GetTitle(self):
 if self.Debug or self.TagName == "":
 if len(self.InstancePath) > 15:
 return "..." + self.InstancePath[-12:]
 return self.InstancePath
 return EditorPanel.GetTitle(self)
 def GetInstancePath(self):
 return self.InstancePath
 def IsViewing(self, tagname):
 if self.Debug or self.TagName == "":
 return self.InstancePath == tagname
 else:
 return self.TagName == tagname
 def GetText(self):
 return self.Editor.GetText()
 def SetText(self, text):
 self.Editor.SetText(text)
 def SelectAll(self):
 self.Editor.SelectAll()
 def Colourise(self, start, end):
 self.Editor.Colourise(start, end)
 def StartStyling(self, pos, mask):
 self.Editor.StartStyling(pos, mask)
 def SetStyling(self, length, style):
 self.Editor.SetStyling(length, style)
 def GetCurrentPos(self):
 return self.Editor.GetCurrentPos()
 def ResetSearchResults(self):
 self.Highlights = []
 self.SearchParams = None
 self.SearchResults = None
 self.CurrentFindHighlight = None
 def OnModification(self, event):
 if not self.DisableEvents:
 mod_type = event.GetModificationType()
 if mod_type&wx.stc.STC_MOD_BEFOREINSERT:
 if self.CurrentAction == None:
 self.Controler.EndBuffering()
 self.StartBuffering()
 self.CurrentAction = ("Delete", event.GetPosition())
 wx.CallAfter(self.RefreshModel)
 event.Skip()
 def OnDoDrop(self, event):
 try:
 values = eval(event.GetDragText())
 except:
 values = event.GetDragText()
 blockname = values[2]
 if len(values) > 3:
 blockinputs = values[3]
 else:
 blockinputs = None
 if values[1] != "function":
 if blockname == "":
 dialog = wx.TextEntryDialog(self.ParentWindow, "Block name", "Please enter a block name", "", wx.OK|wx.CANCEL|wx.CENTRE)
 if dialog.ShowModal() == wx.ID_OK:
 blockname = dialog.GetValue()
 else:
 elif var_name.upper() in [name.upper() for name in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]:
 message = _("\"%s\" element for this pou already exists!")%var_name
 else:
 location = values[0]
 if not location.startswith("%"):
 dialog = wx.SingleChoiceDialog(self.ParentWindow,
 _("Select a variable class:"), _("Variable class"),
 ["Input", "Output", "Memory"],
 wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)
 if dialog.ShowModal() == wx.ID_OK:
 selected = dialog.GetSelection()
 else:
 selected = None
 if values[2] is not None:
 var_type = values[2]
 else:
 var_type = LOCATIONDATATYPES.get(location[2], ["BOOL"])[0]
 self.Controler.AddEditedElementPouVar(self.TagName,
 var_type, var_name,
 location=location, description=values[4])
 self.RefreshVariablePanel()
 self.RefreshVariableTree()
 event.SetDragText(var_name)
 else:
 event.SetDragText("")
+elif values[1] == "NamedConstant":
+pou_name, pou_type = self.Controler.GetEditedElementType(self.TagName, self.Debug)
+if pou_type == "program":
+initval = values[0]
+var_name = values[3]
+if var_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames(self.Debug)]:
+message = _("\"%s\" pou already exists!")%var_name
+else:
+var_type = values[2]
+if not var_name.upper() in [name.upper() for name in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]:
+self.Controler.AddEditedElementPouVar(self.TagName,
+var_type,
+var_name,
+description=values[4], initval=initval)
+self.RefreshVariablePanel()
+self.RefreshVariableTree()
+event.SetDragText(var_name)
 elif values[1] == "Global":
 var_name = values[0]
 if var_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames(self.Debug)]:
 message = _("\"%s\" pou already exists!")%var_name
 else:
 dialog = wx.MessageDialog(self, message, _("Error"), wx.OK|wx.ICON_ERROR)
 dialog.ShowModal()
 dialog.Destroy()
 event.SetDragText("")
 event.Skip()
 def SetTextSyntax(self, syntax):
 self.TextSyntax = syntax
 if syntax in ["ST", "ALL"]:
 self.Editor.SetMarginType(2, wx.stc.STC_MARGIN_SYMBOL)
 self.Editor.SetMarginMask(2, wx.stc.STC_MASK_FOLDERS)
 self.BlockStartKeywords = IEC_BLOCK_START_KEYWORDS
 self.BlockEndKeywords = IEC_BLOCK_START_KEYWORDS
 else:
 self.BlockStartKeywords = []
 self.BlockEndKeywords = []
 def SetKeywords(self, keywords):
 self.Keywords = [keyword.upper() for keyword in keywords]
 self.Colourise(0, -1)
 def RefreshJumpList(self):
 if self.TextSyntax != "IL":
 self.Jumps = [jump.upper() for jump in LABEL_MODEL.findall(self.GetText())]
 self.Colourise(0, -1)
 # Buffer the last model state
 def RefreshBuffer(self):
 self.Controler.BufferProject()
 if self.ParentWindow:
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshFileMenu()
 self.ParentWindow.RefreshEditMenu()
 def StartBuffering(self):
 self.Controler.StartBuffering()
 if self.ParentWindow:
 self.ParentWindow.RefreshTitle()
 self.ParentWindow.RefreshFileMenu()
 self.ParentWindow.RefreshEditMenu()
 def ResetBuffer(self):
 if self.CurrentAction != None:
 self.Controler.EndBuffering()
 self.CurrentAction = None
 def GetBufferState(self):
 if not self.Debug and self.TextSyntax != "ALL":
 return self.Controler.GetBufferState()
 return False, False
 def Undo(self):
 if not self.Debug and self.TextSyntax != "ALL":
 self.Controler.LoadPrevious()
 self.ParentWindow.CloseTabsWithoutModel()
 def Redo(self):
 if not self.Debug and self.TextSyntax != "ALL":
 self.Controler.LoadNext()
 self.ParentWindow.CloseTabsWithoutModel()
 def HasNoModel(self):
 if not self.Debug and self.TextSyntax != "ALL":
 return self.Controler.GetEditedElement(self.TagName) is None
 return False
 def RefreshView(self, variablepanel=True):
 EditorPanel.RefreshView(self, variablepanel)
 if self.Controler is not None:
 self.ResetBuffer()
 self.DisableEvents = True
 old_cursor_pos = self.GetCurrentPos()
 line = self.Editor.GetFirstVisibleLine()
 else:
 self.Editor.GotoPos(old_cursor_pos)
 self.RefreshJumpList()
 self.Editor.EmptyUndoBuffer()
 self.DisableEvents = False
 self.RefreshVariableTree()
 self.TypeNames = [typename.upper() for typename in self.Controler.GetDataTypes(self.TagName, True, self.Debug)]
 self.EnumeratedValues = [value.upper() for value in self.Controler.GetEnumeratedDataValues()]
 self.Functions = {}
 for category in self.Controler.GetBlockTypes(self.TagName, self.Debug):
 for blocktype in category["list"]:
 blockname = blocktype["name"].upper()
 if blocktype["type"] == "function" and blockname not in self.Keywords and blockname not in self.Variables.keys():
 self.Functions[blockname]["interface"].update(interface)
 self.Functions[blockname]["extensible"] |= blocktype["extensible"]
 else:
 self.Functions[blockname] = {"interface": interface,
 "extensible": blocktype["extensible"]}
 self.Colourise(0, -1)
 def RefreshVariableTree(self):
 words = self.TagName.split("::")
 self.Variables = self.GenerateVariableTree(
 [(variable.Name, variable.Type, variable.Tree)
 for variable in self.Controler.GetEditedElementInterfaceVars(
 self.TagName, True, self.Debug)])
 if self.Controler.GetEditedElementType(self.TagName, self.Debug)[1] == "function" or words[0] == "T" and self.TextSyntax == "IL":
 return_type, (var_tree, var_dimension) = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, True, self.Debug)
 if return_type is not None:
 self.Variables[words[-1].upper()] = self.GenerateVariableTree(var_tree)
 else:
 self.Variables[words[-1].upper()] = {}
 def GenerateVariableTree(self, list):
 tree = {}
 for var_name, var_type, (var_tree, var_dimension) in list:
 tree[var_name.upper()] = self.GenerateVariableTree(var_tree)
 return tree
 def IsValidVariable(self, name, context):
 return context is not None and context.get(name, None) is not None
 def IsCallParameter(self, name, call):
 if call is not None:
 return (call["interface"].get(name.upper(), None) is not None or
 call["extensible"] and EXTENSIBLE_PARAMETER.match(name.upper()) is not None)
 return False
 def RefreshLineFolding(self, line_number):
 if self.TextSyntax in ["ST", "ALL"]:
 level = wx.stc.STC_FOLDLEVELBASE + self.Editor.GetLineIndentation(line_number)
 line = self.Editor.GetLine(line_number).strip()
 if line == "":
 if LineStartswith(self.Editor.GetLine(line_number - 1).strip(), self.BlockEndKeywords):
 level = self.Editor.GetFoldLevel(self.Editor.GetFoldParent(line_number - 1)) & wx.stc.STC_FOLDLEVELNUMBERMASK
 else:
 level = self.Editor.GetFoldLevel(line_number - 1) & wx.stc.STC_FOLDLEVELNUMBERMASK
 if level != wx.stc.STC_FOLDLEVELBASE:
 level |=  wx.stc.STC_FOLDLEVELWHITEFLAG
 elif LineStartswith(line, self.BlockStartKeywords):
 level |= wx.stc.STC_FOLDLEVELHEADERFLAG
 elif LineStartswith(line, self.BlockEndKeywords):
 if LineStartswith(self.Editor.GetLine(line_number - 1).strip(), self.BlockEndKeywords):
 level = self.Editor.GetFoldLevel(self.Editor.GetFoldParent(line_number - 1)) & wx.stc.STC_FOLDLEVELNUMBERMASK
 else:
 level = self.Editor.GetFoldLevel(line_number - 1) & wx.stc.STC_FOLDLEVELNUMBERMASK
 self.Editor.SetFoldLevel(line_number, level)
 def OnStyleNeeded(self, event):
 self.TextChanged = True
 line_number = self.Editor.LineFromPosition(self.Editor.GetEndStyled())
 if line_number == 0:
 start_pos = last_styled_pos = 0
 else:
 start_pos = last_styled_pos = self.Editor.GetLineEndPosition(line_number - 1) + 1
 self.RefreshLineFolding(line_number)
 end_pos = event.GetPosition()
 self.StartStyling(start_pos, 0xff)
 current_context = self.Variables
 current_call = None
 current_pos = last_styled_pos
 state = SPACE
 line = ""
 word = ""
 while current_pos < end_pos:
 elif self.IsValidVariable(word, current_context):
 self.SetStyling(current_pos - last_styled_pos, STC_PLC_VARIABLE)
 elif self.IsCallParameter(word, current_call):
 self.SetStyling(current_pos - last_styled_pos, STC_PLC_PARAMETER)
 elif word in self.Functions:
 self.SetStyling(current_pos - last_styled_pos, STC_PLC_FUNCTION)
 elif self.TextSyntax == "IL" and word in self.Jumps:
 self.SetStyling(current_pos - last_styled_pos, STC_PLC_JUMP)
 elif word in self.EnumeratedValues:
 self.SetStyling(current_pos - last_styled_pos, STC_PLC_NUMBER)
 else:
 current_context = self.Variables
 else:
 if char == '[' and current_context is not None:
 self.ContextStack.append(current_context.get(word, None))
 current_context = self.Variables
 word = ""
 last_styled_pos = current_pos
 state = SPACE
 elif state == NUMBER:
 self.SetStyling(current_pos - last_styled_pos, STC_PLC_NUMBER)
 self.SetStyling(current_pos - last_styled_pos, 31)
 else:
 self.SetStyling(current_pos - start_pos, 31)
 self.ShowHighlights(start_pos, end_pos)
 event.Skip()
 def OnMarginClick(self, event):
 if event.GetMargin() == 2:
 line = self.Editor.LineFromPosition(event.GetPosition())
 if self.Editor.GetFoldLevel(line) & wx.stc.STC_FOLDLEVELHEADERFLAG:
 self.Editor.ToggleFold(line)
 event.Skip()
 def OnUpdateUI(self, event):
 selected = self.Editor.GetSelectedText()
 if self.ParentWindow and selected != "":
 self.ParentWindow.SetCopyBuffer(selected, True)
 event.Skip()
 def Cut(self):
 self.ResetBuffer()
 self.DisableEvents = True
 self.Editor.CmdKeyExecute(wx.stc.STC_CMD_CUT)
 self.DisableEvents = False
 self.RefreshModel()
 self.RefreshBuffer()
 def Copy(self):
 self.Editor.CmdKeyExecute(wx.stc.STC_CMD_COPY)
 if self.ParentWindow:
 self.ParentWindow.RefreshEditMenu()
 def Paste(self):
 self.ResetBuffer()
 self.DisableEvents = True
 self.Editor.CmdKeyExecute(wx.stc.STC_CMD_PASTE)
 self.DisableEvents = False
 self.RefreshModel()
 self.RefreshBuffer()
 def Search(self, criteria):
 return self.Controler.SearchInPou(self.TagName, criteria, self.Debug)
 def Find(self, direction, search_params):
 if self.SearchParams != search_params:
 self.ClearHighlights(SEARCH_RESULT_HIGHLIGHT)
 self.SearchParams = search_params
 criteria = {
 "raw_pattern": search_params["find_pattern"],
 "pattern": re.compile(search_params["find_pattern"]),
 "case_sensitive": search_params["case_sensitive"],
 "regular_expression": search_params["regular_expression"],
 "filter": "all"}
 self.SearchResults = [
 (infos[1:], start, end, SEARCH_RESULT_HIGHLIGHT)
 for infos, start, end, text in
 self.Search(criteria)]
 self.CurrentFindHighlight = None
 if len(self.SearchResults) > 0:
 if self.CurrentFindHighlight is not None:
 old_idx = self.SearchResults.index(self.CurrentFindHighlight)
 if self.SearchParams["wrap"]:
 idx = (old_idx + direction) % len(self.SearchResults)
 self.CurrentFindHighlight = self.SearchResults[idx]
 self.AddHighlight(*self.CurrentFindHighlight)
 else:
 self.CurrentFindHighlight = self.SearchResults[0]
 self.AddHighlight(*self.CurrentFindHighlight)
 else:
 if self.CurrentFindHighlight is not None:
 self.RemoveHighlight(*self.CurrentFindHighlight)
 self.CurrentFindHighlight = None
 def RefreshModel(self):
 self.RefreshJumpList()
 self.Controler.SetEditedElementText(self.TagName, self.GetText())
 self.ResetSearchResults()
 def OnKeyDown(self, event):
 key = event.GetKeyCode()
 if self.Controler is not None:
 if self.Editor.CallTipActive():
 self.Editor.CallTipCancel()
 key_handled = False
 line = self.Editor.GetCurrentLine()
 if line == 0:
 start_pos = 0
 else:
 start_pos = self.Editor.GetLineEndPosition(line - 1) + 1
 end_pos = self.GetCurrentPos()
 lineText = self.Editor.GetTextRange(start_pos, end_pos).replace("\t", " ")
 # Code completion
 if key == wx.WXK_SPACE and event.ControlDown():
 words = lineText.split(" ")
 words = [word for i, word in enumerate(words) if word != '' or i == len(words) - 1]
 kw = []
 if self.TextSyntax == "IL":
 if len(words) == 1:
 kw = self.Keywords
 elif len(words) == 2:
 if words[0].upper() in ["CAL", "CALC", "CALNC"]:
 self.RefreshView()
 event.Skip()
 def ClearHighlights(self, highlight_type=None):
 EditorPanel.ClearHighlights(self, highlight_type)
 if highlight_type is None:
 self.Highlights = []
 else:
 highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)
 if highlight_type is not None:
 self.Highlights = [(infos, start, end, highlight) for (infos, start, end, highlight) in self.Highlights if highlight != highlight_type]
 self.RefreshView()
 def AddHighlight(self, infos, start, end, highlight_type):
 EditorPanel.AddHighlight(self, infos, start, end, highlight_type)
 highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)
 if infos[0] == "body" and highlight_type is not None:
 self.Highlights.append((infos[1], start, end, highlight_type))
 self.Editor.GotoPos(self.Editor.PositionFromLine(start[0]) + start[1])
 self.RefreshHighlightsTimer.Start(int(REFRESH_HIGHLIGHT_PERIOD * 1000), oneShot=True)
 def RemoveHighlight(self, infos, start, end, highlight_type):
 EditorPanel.RemoveHighlight(self, infos, start, end, highlight_type)
 highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)
 if (infos[0] == "body" and highlight_type is not None and
 (infos[1], start, end, highlight_type) in self.Highlights):
 self.Highlights.remove((infos[1], start, end, highlight_type))
 self.RefreshHighlightsTimer.Start(int(REFRESH_HIGHLIGHT_PERIOD * 1000), oneShot=True)
 def ShowHighlights(self, start_pos, end_pos):
 for indent, start, end, highlight_type in self.Highlights:
 if start[0] == 0:
 highlight_start_pos = start[1] - indent
 else:
 if highlight_start_pos < end_pos and highlight_end_pos > start_pos:
 self.StartStyling(highlight_start_pos, 0xff)
 self.SetStyling(highlight_end_pos - highlight_start_pos, highlight_type)
 self.StartStyling(highlight_start_pos, 0x00)
 self.SetStyling(len(self.Editor.GetText()) - highlight_end_pos, wx.stc.STC_STYLE_DEFAULT)

changeset 1409	48f5f2a622c8
parent 1406	82db84fe88ea
child 1417	374238039643