Logo Search packages:      
Sourcecode: wxwindows2.4 version File versions

stc_.py

00001 """StyledTextCtrl decorator class module.
"""

__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
__cvsid__ = "$Id: stc_.py,v 1.1.2.2 2003/09/25 21:51:59 PKO Exp $"
__revision__ = "$Revision: 1.1.2.2 $"[11:-2]


# These are not the real wxPython classes. These are Python versions
# for documentation purposes. They are also used to apply docstrings
# to the real wxPython classes, which are SWIG-generated wrappers for
# C-language classes.


from Controls import Control
import Parameters as wx


00019 class StyledTextCtrl(Control):
    """StyledTextCtrl class."""

00022     def __init__(self, parent, id, pos=wx.DefaultPosition,
                 size=wx.DefaultSize, style=0, name=wx.PySTCNameStr):
        """Create a StyledTextCtrl instance."""
        pass

00027     def AddRefDocument(self, docPointer):
        """Extend life of document."""
        pass

00031     def AddStyledText(self, data):
        """Add array of cells to document."""
        pass

00035     def AddText(self, text):
        """Add text to the document."""
        pass

00039     def AutoCompActive(self):
        """Is there an auto-completion list visible?"""
        pass

00043     def AutoCompCancel(self):
        """Remove the auto-completion list from the screen."""
        pass

00047     def AutoCompComplete(self):
        """User has selected an item so remove the list and insert the
        selection."""
        pass

00052     def AutoCompGetAutoHide(self):
        """Return whether or not autocompletion is hidden
        automatically when nothing matches."""
        pass

00057     def AutoCompGetCancelAtStart(self):
        """Return whether auto-completion cancelled by backspacing
        before start."""
        pass

00062     def AutoCompGetChooseSingle(self):
        """Return whether a single item auto-completion list
        automatically choose the item."""
        pass

00067     def AutoCompGetDropRestOfWord(self):
        """Return whether or not autocompletion deletes any word
        characters after the inserted text upon completion."""
        pass

00072     def AutoCompGetIgnoreCase(self):
        """Return state of ignore case flag."""
        pass

00076     def AutoCompGetSeparator(self):
        """Return the auto-completion list separator character."""
        pass

00080     def AutoCompPosStart(self):
        """Return the position of the caret when the auto-completion
        list was displayed."""
        pass

00085     def AutoCompSelect(self, text):
        """Select the item in the auto-completion list that starts
        with a string."""
        pass

00090     def AutoCompSetAutoHide(self, autoHide):
        """Set whether or not autocompletion is hidden automatically
        when nothing matches."""
        pass

00095     def AutoCompSetCancelAtStart(self, cancel):
        """Should the auto-completion list be cancelled if the user
        backspaces to a position before where the box was created."""
        pass

00100     def AutoCompSetChooseSingle(self, chooseSingle):
        """Should a single item auto-completion list automatically
        choose the item."""
        pass

00105     def AutoCompSetDropRestOfWord(self, dropRestOfWord):
        """Set whether or not autocompletion deletes any word
        characters after the inserted text upon completion."""
        pass

00110     def AutoCompSetFillUps(self, characterSet):
        """Define a set of characters that when typed will cause the
        autocompletion to choose the selected item."""
        pass

00115     def AutoCompSetIgnoreCase(self, ignoreCase):
        """Set whether case is significant when performing
        auto-completion searches."""
        pass

00120     def AutoCompSetSeparator(self, separatorCharacter):
        """Change the separator character in the string setting up an
        auto-completion list.  Default is space but can be changed if
        items contain space."""
        pass

00126     def AutoCompShow(self, lenEntered, itemList):
        """Display a auto-completion list.

        The lenEntered parameter indicates how many characters before
        the caret should be used to provide context."""
        pass

00133     def AutoCompStops(self, characterSet):
        """Define a set of character that when typed cancel the
        auto-completion list."""
        pass

00138     def BeginUndoAction(self):
        """Start a sequence of actions that is undone and redone as a
        unit.  May be nested."""
        pass

00143     def BraceBadLight(self, pos):
        """Highlight the character at a position indicating there is
        no matching brace."""
        pass

00148     def BraceHighlight(self, pos1, pos2):
        """Highlight the characters at two positions."""
        pass

00152     def BraceMatch(self, pos):
        """Find the position of a matching brace or INVALID_POSITION
        if no match."""
        pass

00157     def CallTipActive(self):
        """Is there an active call tip?"""
        pass

00161     def CallTipCancel(self):
        """Remove the call tip from the screen."""
        pass

00165     def CallTipPosAtStart(self):
        """Return the position where the caret was before displaying
        the call tip."""
        pass

00170     def CallTipSetBackground(self, back):
        """Set the background colour for the call tip."""
        pass

00174     def CallTipSetHighlight(self, start, end):
        """Highlight a segment of the definition."""
        pass

00178     def CallTipShow(self, pos, definition):
        """Show a call tip containing a definition near position pos."""
        pass

00182     def CanPaste(self):
        """Will a paste succeed?"""
        pass

00186     def CanRedo(self):
        """Are there any redoable actions in the undo history?"""
        pass

00190     def CanUndo(self):
        """Are there any undoable actions in the undo history?"""
        pass

00194     def Clear(self):
        """Clear the selection."""
        pass

00198     def ClearAll(self):
        """Delete all text in the document."""
        pass

00202     def ClearDocumentStyle(self):
        """Set all style bytes to 0, remove all folding information."""
        pass

00206     def CmdKeyAssign(self, key, modifiers, cmd):
        """When key+modifier combination km is pressed perform msg."""
        pass

00210     def CmdKeyClear(self, key, modifiers):
        """When key+modifier combination km do nothing."""
        pass

00214     def CmdKeyClearAll(self):
        """Drop all key mappings."""
        pass

00218     def CmdKeyExecute(self, cmd):
        """Perform one of the operations defined by the STC_CMD_*
        constants."""
        pass

00223     def Colourise(self, start, end):
        """Colourise a segment of the document using the current
        lexing language."""
        pass

00228     def ConvertEOLs(self, eolMode):
        """Convert all line endings in the document to one mode."""
        pass

00232     def Copy(self):
        """Copy the selection to the clipboard."""
        pass

00236     def CreateDocument(self):
        """Create a new document object.

        Starts with reference count of 1 and not selected into editor."""
        pass

00242     def Cut(self):
        """Cut the selection to the clipboard."""
        pass

00246     def DelLineLeft(self):
        """Delete from the current position to the start of the line."""
        pass

00250     def DelLineRight(self):
        """Delete from the current position to the end of the line."""
        pass

00254     def DocLineFromVisible(self, lineDisplay):
        """Find the document line of a display line taking hidden
        lines into account."""
        pass

00259     def EmptyUndoBuffer(self):
        """Delete the undo history."""
        pass

00263     def EndUndoAction(self):
        """End a sequence of actions that is undone and redone as a
        unit."""
        pass

00268     def EnsureCaretVisible(self):
        """Ensure the caret is visible."""
        pass

00272     def EnsureVisible(self, line):
        """Ensure a particular line is visible by expanding any header
        line hiding it."""
        pass

00277     def EnsureVisibleEnforcePolicy(self, line):
        """Ensure a particular line is visible by expanding any header
        line hiding it.  Use the currently set visibility policy to
        determine which range to display."""
        pass

00283     def FindText(self, minPos, maxPos, text, flags=0):
        """Find some text in the document."""
        pass

00287     def FormatRange(self, doDraw, startPos, endPos, draw,
                    target, renderRect, pageRect):
        """On Windows, will draw the document into a display context
        such as a printer."""
        pass

00293     def GetAnchor(self):
        """Return the position of the opposite end of the selection to
        the caret."""
        pass

00298     def GetBackSpaceUnIndents(self):
        """Does a backspace pressed when caret is within indentation
        unindent?"""
        pass

00303     def GetBufferedDraw(self):
        """Is drawing done first into a buffer or direct to the
        screen?"""
        pass

00308     def GetCaretForeground(self):
        """Return the foreground colour of the caret."""
        pass

00312     def GetCaretLineBack(self):
        """Return the colour of the background of the line containing
        the caret."""
        pass

00317     def GetCaretLineVisible(self):
        """Is the background of the line containing the caret in a
        different colour?"""
        pass

00322     def GetCaretPeriod(self):
        """Return the time in milliseconds that the caret is on and
        off."""
        pass

00327     def GetCaretWidth(self):
        """Return the width of the insert mode caret."""
        pass

00331     def GetCharAt(self, pos):
        """Return the character byte at the position."""
        pass

00335     def GetCodePage(self):
        """Return the code page used to interpret the bytes of the
        document as characters."""
        pass

00340     def GetColumn(self, pos):
        """Return the column number of a position, taking tab width
        into account."""
        pass

00345     def GetControlCharSymbol(self):
        """Return the way control characters are displayed."""
        pass

00349     def GetCurLine(self):
        """Return (text, pos) tuple with the text of the line
        containing the caret and the position of the caret within the
        line."""
        pass

00355     def GetCurrentLine(self):
        """Return the line number of the line with the caret."""
        pass

00359     def GetCurrentPos(self):
        """Return the position of the caret."""
        pass

00363     def GetCursor(self):
        """Return cursor type."""
        pass

00367     def GetDocPointer(self):
        """Return a pointer to the document object."""
        pass

00371     def GetEOLMode(self):
        """Return the current end of line mode: CRLF, CR, or LF."""
        pass

00375     def GetEdgeColour(self):
        """Return the colour used in edge indication."""
        pass

00379     def GetEdgeColumn(self):
        """Return the column number which text should be kept within."""
        pass

00383     def GetEdgeMode(self):
        """Return the edge highlight mode."""
        pass

00387     def GetEndAtLastLine(self):
        """Return whether the maximum scroll position has the last
        line at the bottom of the view."""
        pass

00392     def GetEndStyled(self):
        """Return the position of the last correctly styled character."""
        pass

00396     def GetFirstVisibleLine(self):
        """Return the line at the top of the display."""
        pass

00400     def GetFoldExpanded(self, line):
        """Is a header line expanded?"""
        pass

00404     def GetFoldLevel(self, line):
        """Return the fold level of a line."""
        pass

00408     def GetFoldParent(self, line):
        """Find the parent line of a child line."""
        pass

00412     def GetHighlightGuide(self):
        """Return the highlighted indentation guide column."""
        pass

00416     def GetIndent(self):
        """Return indentation size."""
        pass

00420     def GetIndentationGuides(self):
        """Are the indentation guides visible?"""
        pass

00424     def GetLastChild(self, line, level):
        """Find the last child line of a header line."""
        pass

00428     def GetLastKeydownProcessed(self):
        """Can be used to prevent the EVT_CHAR handler from adding the
        char."""
        pass

00433     def GetLayoutCache(self):
        """Return the degree of caching of layout information."""
        pass

00437     def GetLength(self):
        """Return the number of characters in the document."""
        pass

00441     def GetLexer(self):
        """Return the lexing language of the document."""
        pass

00445     def GetLine(self, line):
        """Return the contents of a line."""
        pass

00449     def GetLineCount(self):
        """Return the number of lines in the document. There is
        always at least one."""
        pass

00454     def GetLineEndPosition(self, line):
        """Return the position after the last visible characters on a
        line."""
        pass

00459     def GetLineIndentPosition(self, line):
        """Return the position before the first non indentation
        character on a line."""
        pass

00464     def GetLineIndentation(self, line):
        """Return the number of columns that a line is indented."""
        pass

00468     def GetLineState(self, line):
        """Return the extra styling information for a line."""
        pass

00472     def GetLineVisible(self, line):
        """Is a line visible?"""
        pass

00476     def GetMarginLeft(self):
        """Return the size in pixels of the left margin."""
        pass

00480     def GetMarginMask(self, margin):
        """Return the marker mask of a margin."""
        pass

00484     def GetMarginRight(self):
        """Return the size in pixels of the right margin."""
        pass

00488     def GetMarginSensitive(self, margin):
        """Return the mouse click sensitivity of a margin."""
        pass

00492     def GetMarginType(self, margin):
        """Return the type of a margin."""
        pass

00496     def GetMarginWidth(self, margin):
        """Return the width of a margin in pixels."""
        pass

00500     def GetMaxLineState(self):
        """Return the last line number that has line state."""
        pass

00504     def GetModEventMask(self):
        """Return which document modification events are sent to the
        container."""
        pass

00509     def GetModify(self):
        """Is the document different from when it was last saved?"""
        pass

00513     def GetMouseDownCaptures(self):
        """Return whether mouse gets captured."""
        pass

00517     def GetMouseDwellTime(self):
        """Return the time the mouse must sit still to generate a
        mouse dwell event."""
        pass

00522     def GetOvertype(self):
        """Return true if overtype mode is active otherwise false is
        returned."""
        pass

00527     def GetPrintColourMode(self):
        """Return the print colour mode."""
        pass

00531     def GetPrintMagnification(self):
        """Return the print magnification."""
        pass

00535     def GetReadOnly(self):
        """In read-only mode?"""
        pass

00539     def GetSTCFocus(self):
        """Return internal focus flag."""
        pass

00543     def GetScrollWidth(self):
        """Return the document width assumed for scrolling."""
        pass

00547     def GetSearchFlags(self):
        """Return the search flags used by SearchInTarget."""
        pass

00551     def GetSelectedText(self):
        """Return the selected text."""
        pass

00555     def GetSelectionEnd(self):
        """Return the position at the end of the selection."""
        pass

00559     def GetSelection(self):
        """Return the start and end positions of the current
        selection."""
        pass

00564     def GetSelectionStart(self):
        """Return the position at the start of the selection."""
        pass

00568     def GetStatus(self):
        """Return error status."""
        pass

00572     def GetStyleAt(self, pos):
        """Return the style byte at the position."""
        pass

00576     def GetStyleBits(self):
        """Return number of bits in style bytes used to hold the
        lexical state."""
        pass

00581     def GetStyledText(self, startPos, endPos):
        """Return a buffer of cells."""
        pass

00585     def GetTabIndents(self):
        """Does a tab pressed when caret is within indentation indent?"""
        pass

00589     def GetTabWidth(self):
        """Return the visible size of a tab."""
        pass

00593     def GetTargetEnd(self):
        """Return the position that ends the target."""
        pass

00597     def GetTargetStart(self):
        """Return the position that starts the target."""
        pass

00601     def GetText(self):
        """Return all the text in the document."""
        pass

00605     def GetTextLength(self):
        """Return the number of characters in the document."""
        pass

00609     def GetTextRange(self, startPos, endPos):
        """Return a range of text."""
        pass

00613     def GetUndoCollection(self):
        """Is undo history being collected?"""
        pass

00617     def GetUseHorizontalScrollBar(self):
        """Is the horizontal scroll bar visible?"""
        pass

00621     def GetUseTabs(self):
        """Return whether tabs will be used in indentation."""
        pass

00625     def GetViewEOL(self):
        """Are the end of line characters visible?"""
        pass

00629     def GetViewWhiteSpace(self):
        """Are white space characters currently visible? Return one
        of SCWS_* constants."""
        pass

00634     def GetWrapMode(self):
        """Return whether text is word wrapped."""
        pass

00638     def GetXOffset(self):
        """Return the xOffset (self, ie, horizonal scroll position)."""
        pass

00642     def GetZoom(self):
        """Return the zoom level."""
        pass

00646     def GotoLine(self, line):
        """Set caret to start of a line and ensure it is visible."""
        pass

00650     def GotoPos(self, pos):
        """Set caret to a position and ensure it is visible."""
        pass

00654     def HideLines(self, lineStart, lineEnd):
        """Make a range of lines invisible."""
        pass

00658     def HideSelection(self, normal):
        """Draw the selection in normal style or with selection
        highlighted."""
        pass

00663     def HomeDisplay(self):
        """Move caret to first position on display line."""
        pass

00667     def HomeDisplayExtend(self):
        """Move caret to first position on display line extending
        selection to new caret position."""
        pass

00672     def IndicatorGetForeground(self, indic):
        """Return the foreground colour of an indicator."""
        pass

00676     def IndicatorGetStyle(self, indic):
        """Return the style of an indicator."""
        pass

00680     def IndicatorSetForeground(self, indic, fore):
        """Set the foreground colour of an indicator."""
        pass

00684     def IndicatorSetStyle(self, indic, style):
        """Set an indicator to plain, squiggle or TT."""
        pass

00688     def InsertText(self, pos, text):
        """Insert string at a position."""
        pass

00692     def LineEndDisplay(self):
        """Move caret to last position on display line."""
        pass

00696     def LineEndDisplayExtend(self):
        """Move caret to last position on display line extending
        selection to new caret position."""
        pass

00701     def LineFromPosition(self, pos):
        """Return the line containing a position."""
        pass

00705     def LineLength(self, line):
        """How many characters are on a line, not including end of
        line characters?"""
        pass

00710     def LineScroll(self, columns, lines):
        """Scroll horizontally and vertically."""
        pass

00714     def LinesOnScreen(self):
        """Retrieves the number of lines completely visible."""
        pass

00718     def MarkerAdd(self, line, markerNumber):
        """Add a marker to a line, return an ID that can be used to
        find or delete the marker."""
        pass

00723     def MarkerDefine(self, markerNumber, markerSymbol,
                     foreground=wx.NullColour, background=wx.NullColour):
        """Set the symbol used for a particular marker number, and
        optionally the fore and background colours."""
        pass

00729     def MarkerDelete(self, line, markerNumber):
        """Delete a marker from a line."""
        pass

00733     def MarkerDeleteAll(self, markerNumber):
        """Delete all markers with a particular number from all lines."""
        pass

00737     def MarkerDeleteHandle(self, handle):
        """Delete a marker."""
        pass

00741     def MarkerGet(self, line):
        """Return a bit mask of all the markers set on a line."""
        pass

00745     def MarkerLineFromHandle(self, handle):
        """Return the line number at which a particular marker is
        located."""
        pass

00750     def MarkerNext(self, lineStart, markerMask):
        """Find the next line after lineStart that includes a marker
        in mask."""
        pass

00755     def MarkerPrevious(self, lineStart, markerMask):
        """Find the previous line before lineStart that includes a
        marker in mask."""
        pass

00760     def MarkerSetBackground(self, markerNumber, back):
        """Set the background colour used for a particular marker
        number."""
        pass

00765     def MarkerSetForeground(self, markerNumber, fore):
        """Set the foreground colour used for a particular marker
        number."""
        pass

00770     def MoveCaretInsideView(self):
        """Move the caret inside current view if it is not there
        already."""
        pass

00775     def Paste(self):
        """Paste the contents of the clipboard into the document
        replacing the selection."""
        pass

00780     def PointFromPosition(self, pos):
        """Return the point in the window where a position is
        displayed."""
        pass

00785     def PositionFromLine(self, line):
        """Return the position at the start of a line."""
        pass

00789     def PositionFromPoint(self, pt):
        """Find the position from a point within the window."""
        pass

00793     def PositionFromPointClose(self, x, y):
        """Find the position from a point within the window but return
        INVALID_POSITION if not close to text."""
        pass

00798     def Redo(self):
        """Redo the next action on the undo history."""
        pass

00802     def ReleaseDocument(self, docPointer):
        """Release a reference to the document, deleting document if
        it fades to black."""
        pass

00807     def ReplaceSelection(self, text):
        """Replace the selected text with the argument text."""
        pass

00811     def ReplaceTarget(self, text):
        """Replace the target text with the argument text.

        Text is counted so it can contain nulls.  Return the length
        of the replacement text."""
        pass

00818     def ReplaceTargetRE(self, text):
        """Replace the target text with the argument text after \d
        processing.

        Text is counted so it can contain nulls.  Looks for \d where d
        is between 1 and 9 and replaces these with the strings matched
        in the last search operation which were surrounded by \(self,
        and \).  Return the length of the replacement text including
        any change caused by processing the \d patterns."""
        pass

00829     def ScrollToColumn(self, column):
        """Scroll enough to make the given column visible."""
        pass

00833     def ScrollToLine(self, line):
        """Scroll enough to make the given line visible."""
        pass

00837     def SearchAnchor(self):
        """Sets the current caret position to be the search anchor."""
        pass

00841     def SearchInTarget(self, text):
        """Search for a counted string in the target and set the
        target to the found range.

        Text is counted so it can contain nulls.  Return length of
        range or -1 for failure in which case target is not moved."""
        pass

00849     def SearchNext(self, flags, text):
        """Find some text starting at the search anchor.  Does not
        ensure the selection is visible."""
        pass

00854     def SearchPrev(self, flags, text):
        """Find some text starting at the search anchor and moving
        backwards.  Does not ensure the selection is visible."""
        pass

00859     def SelectAll(self):
        """Select all the text in the document."""
        pass

00863     def SelectionIsRectangle(self):
        """Is the selection rectangular?  The alternative is the more
        common stream selection."""
        pass

00868     def SendMsg(self, msg, wp=0, lp=0):
        """Send a message to Scintilla."""
        pass

00872     def SetAnchor(self, posAnchor):
        """Set the selection anchor to a position.  The anchor is the
        opposite end of the selection from the caret."""
        pass

00877     def SetBackSpaceUnIndents(self, bsUnIndents):
        """Sets whether a backspace pressed when caret is within
        indentation unindents."""
        pass

00882     def SetBufferedDraw(self, buffered):
        """If drawing is buffered then each line of text is drawn into
        a bitmap buffer before drawing it to the screen to avoid
        flicker."""
        pass

00888     def SetCaretForeground(self, fore):
        """Set the foreground colour of the caret."""
        pass

00892     def SetCaretLineBack(self, back):
        """Set the colour of the background of the line containing the
        caret."""
        pass

00897     def SetCaretLineVisible(self, show):
        """Display the background of the line containing the caret in
        a different colour."""
        pass

00902     def SetCaretPeriod(self, periodMilliseconds):
        """Return the time in milliseconds that the caret is on and
        off. 0 = steady on."""
        pass

00907     def SetCaretWidth(self, pixelWidth):
        """Set the width of the insert mode caret."""
        pass

00911     def SetCodePage(self, codePage):
        """Set the code page used to interpret the bytes of the
        document as characters."""
        pass

00916     def SetControlCharSymbol(self, symbol):
        """Change the way control characters are displayed: If symbol
        is < 32, keep the drawn way, else, use the given character."""
        pass

00921     def SetCurrentPos(self, pos):
        """Sets the position of the caret."""
        pass

00925     def SetCursor(self, cursorType):
        """Sets the cursor to one of the SC_CURSOR* values."""
        pass

00929     def SetDocPointer(self, docPointer):
        """Change the document object used."""
        pass

00933     def SetEOLMode(self, eolMode):
        """Set the current end of line mode."""
        pass

00937     def SetEdgeColour(self, edgeColour):
        """Change the colour used in edge indication."""
        pass

00941     def SetEdgeColumn(self, column):
        """Set the column number of the edge.  If text goes past the
        edge then it is highlighted."""
        pass

00946     def SetEdgeMode(self, mode):
        """The edge may be displayed by a line (self, EDGE_LINE) or by
        highlighting text that goes beyond it (self, EDGE_BACKGROUND)
        or not displayed at all (self, EDGE_NONE)."""
        pass

00952     def SetEndAtLastLine(self, endAtLastLine):
        """Sets the scroll range so that maximum scroll position has
        the last line at the bottom of the view (self, default).
        Setting this to false allows scrolling one page below the last
        line."""
        pass

00959     def SetFoldExpanded(self, line, expanded):
        """Show the children of a header line."""
        pass

00963     def SetFoldFlags(self, flags):
        """Set some debugging options for folding."""
        pass

00967     def SetFoldLevel(self, line, level):
        """Set the fold level of a line.  This encodes an integer
        level along with flags indicating whether the line is a header
        and whether it is effectively white space."""
        pass

00973     def SetHScrollBar(self, bar):
        """Set the horizontal scrollbar to use instead of the one
        that's built-in."""
        pass

00978     def SetHighlightGuide(self, column):
        """Set the highlighted indentation guide column.  0 = no
        highlighted guide."""
        pass

00983     def SetIndent(self, indentSize):
        """Set the number of spaces used for one level of indentation."""
        pass

00987     def SetIndentationGuides(self, show):
        """Show or hide indentation guides."""
        pass

00991     def SetKeyWords(self, keywordSet, keyWords):
        """Set up the key words used by the lexer."""
        pass

00995     def SetLastKeydownProcessed(self, val):
        """Set ???."""
        pass

00999     def SetLayoutCache(self, mode):
        """Sets the degree of caching of layout information."""
        pass

01003     def SetLexer(self, lexer):
        """Set the lexing language of the document."""
        pass

01007     def SetLexerLanguage(self, language):
        """Set the lexing language of the document based on string
        name."""
        pass

01012     def SetLineIndentation(self, line, indentSize):
        """Change the indentation of a line to a number of columns."""
        pass

01016     def SetLineState(self, line, state):
        """Used to hold extra styling information for each line."""
        pass

01020     def SetMarginLeft(self, pixelWidth):
        """Sets the size in pixels of the left margin."""
        pass

01024     def SetMarginMask(self, margin, mask):
        """Set a mask that determines which markers are displayed in a
        margin."""
        pass

01029     def SetMarginRight(self, pixelWidth):
        """Sets the size in pixels of the right margin."""
        pass

01033     def SetMarginSensitive(self, margin, sensitive):
        """Make a margin sensitive or insensitive to mouse clicks."""
        pass

01037     def SetMarginType(self, margin, marginType):
        """Set a margin to be either numeric or symbolic."""
        pass

01041     def SetMarginWidth(self, margin, pixelWidth):
        """Set the width of a margin to a width expressed in pixels."""
        pass

01045     def SetMargins(self, left, right):
        """Set the left and right margin in the edit area, measured in
        pixels."""
        pass

01050     def SetModEventMask(self, mask):
        """Set which document modification events are sent to the
        container."""
        pass

01055     def SetMouseDownCaptures(self, captures):
        """Set whether the mouse is captured when its button is
        pressed."""
        pass

01060     def SetMouseDwellTime(self, periodMilliseconds):
        """Sets the time the mouse must sit still to generate a mouse
        dwell event."""
        pass

01065     def SetOvertype(self, overtype):
        """Set to overtype (self, true) or insert mode."""
        pass

01069     def SetPrintColourMode(self, mode):
        """Modify colours when printing for clearer printed text."""
        pass

01073     def SetPrintMagnification(self, magnification):
        """Sets the print magnification added to the point size of
        each style for printing."""
        pass

01078     def SetProperty(self, key, value):
        """Set up a value that may be used by a lexer for some
        optional feature."""
        pass

01083     def SetReadOnly(self, readOnly):
        """Set to read only or read write."""
        pass

01087     def SetSTCFocus(self, focus):
        """Change internal focus flag."""
        pass

01091     def SetSavePoint(self):
        """Remember the current position in the undo history as the
        position at which the document was saved."""
        pass

01096     def SetScrollWidth(self, pixelWidth):
        """Sets the document width assumed for scrolling."""
        pass

01100     def SetSearchFlags(self, flags):
        """Set the search flags used by SearchInTarget."""
        pass

01104     def SetSelBackground(self, useSetting, back):
        """Set the background colour of the selection and whether to
        use this setting."""
        pass

01109     def SetSelForeground(self, useSetting, fore):
        """Set the foreground colour of the selection and whether to
        use this setting."""
        pass

01114     def SetSelection(self, start, end):
        """Select a range of text."""
        pass

01118     def SetSelectionEnd(self, pos):
        """Sets the position that ends the selection - this becomes
        the currentPosition."""
        pass

01123     def SetSelectionStart(self, pos):
        """Sets the position that starts the selection - this becomes
        the anchor."""
        pass

01128     def SetStatus(self, statusCode):
        """Change error status - 0 = OK."""
        pass

01132     def SetStyleBits(self, bits):
        """Divide each styling byte into lexical class bits (self,
        default: 5) and indicator bits (self, default: 3). If a lexer
        requires more than 32 lexical states, then this is used to
        expand the possible states."""
        pass

01139     def SetStyleBytes(self, length, styleBytes):
        """Set the styles for a segment of the document."""
        pass

01143     def SetStyling(self, length, style):
        """Change style from current styling position for length
        characters to a style and move the current styling position to
        after this newly styled segment."""
        pass

01149     def SetTabIndents(self, tabIndents):
        """Sets whether a tab pressed when caret is within indentation
        indents."""
        pass

01154     def SetTabWidth(self, tabWidth):
        """Change the visible size of a tab to be a multiple of the
        width of a space character."""
        pass

01159     def SetTargetEnd(self, pos):
        """Sets the position that ends the target which is used for
        updating the document without affecting the scroll position."""
        pass

01164     def SetTargetStart(self, pos):
        """Sets the position that starts the target which is used for
        updating the document without affecting the scroll position."""
        pass

01169     def SetText(self, text):
        """Replace the contents of the document with the argument
        text."""
        pass

01174     def SetUndoCollection(self, collectUndo):
        """Choose between collecting actions into the undo history and
        discarding them."""
        pass

01179     def SetUseHorizontalScrollBar(self, show):
        """Show or hide the horizontal scroll bar."""
        pass

01183     def SetUseTabs(self, useTabs):
        """Indentation will only use space characters if useTabs is
        false, otherwise it will use a combination of tabs and spaces."""
        pass

01188     def SetVScrollBar(self, bar):
        """Set the vertical scrollbar to use instead of the one that's
        built-in."""
        pass

01193     def SetViewEOL(self, visible):
        """Make the end of line characters visible or invisible."""
        pass

01197     def SetViewWhiteSpace(self, viewWS):
        """Make white space characters invisible, always visible or
        visible outside indentation."""
        pass

01202     def SetVisiblePolicy(self, visiblePolicy, visibleSlop):
        """Set the way the display area is determined when a
        particular line is to be moved to by Find, FindNext, GotoLine,
        etc."""
        pass

01208     def SetWhitespaceBackground(self, useSetting, back):
        """Set the background colour of all whitespace and whether to
        use this setting."""
        pass

01213     def SetWhitespaceForeground(self, useSetting, fore):
        """Set the foreground colour of all whitespace and whether to
        use this setting."""
        pass

01218     def SetWordChars(self, characters):
        """Set the set of characters making up words for when moving
        or selecting by word."""
        pass

01223     def SetWrapMode(self, mode):
        """Sets whether text is word wrapped."""
        pass

01227     def SetXCaretPolicy(self, caretPolicy, caretSlop):
        """Set the way the caret is kept visible when going sideway.
        The exclusion zone is given in pixels."""
        pass

01232     def SetXOffset(self, newOffset):
        """Set the xOffset (self, ie, horizonal scroll position)."""
        pass

01236     def SetYCaretPolicy(self, caretPolicy, caretSlop):
        """Set the way the line the caret is on is kept visible.  The
        exclusion zone is given in lines."""
        pass

01241     def SetZoom(self, zoom):
        """Set the zoom level. This number of points is added to the
        size of all fonts.  It may be positive to magnify or negative
        to reduce."""
        pass

01247     def ShowLines(self, lineStart, lineEnd):
        """Make a range of lines visible."""
        pass

01251     def StartRecord(self):
        """Start notifying the container of all key presses and
        commands."""
        pass

01256     def StartStyling(self, pos, mask):
        """Set the current styling position and mask.

        The styling mask can be used to protect some bits in each
        styling byte from modification."""
        pass

01263     def StopRecord(self):
        """Stop notifying the container of all key presses and
        commands."""
        pass

01268     def StyleClearAll(self):
        """Clear all the styles and make equivalent to the global
        default style."""
        pass

01273     def StyleResetDefault(self):
        """Reset the default style to its state at startup."""
        pass

01277     def StyleSetBackground(self, style, back):
        """Set the background colour of a style."""
        pass

01281     def StyleSetBold(self, style, bold):
        """Set a style to be bold or not."""
        pass

01285     def StyleSetCase(self, style, caseForce):
        """Set a style to be mixed case, or to force upper or lower
        case."""
        pass

01290     def StyleSetChangeable(self, style, changeable):
        """Set a style to be changeable or not (self, read only).
        Experimental feature, currently buggy."""
        pass

01295     def StyleSetCharacterSet(self, style, characterSet):
        """Set the character set of the font in a style."""
        pass

01299     def StyleSetEOLFilled(self, style, filled):
        """Set a style to have its end of line filled or not."""
        pass

01303     def StyleSetFaceName(self, style, fontName):
        """Set the font of a style."""
        pass

01307     def StyleSetFont(self, styleNum, font):
        """Set style size, face, bold, italic, and underline
        attributes from a Font's attributes."""
        pass

01312     def StyleSetFontAttr(self, styleNum, size, faceName,
                         bold, italic, underline):
        """Set all font style attributes at once."""
        pass

01317     def StyleSetForeground(self, style, fore):
        """Set the foreground colour of a style."""
        pass

01321     def StyleSetItalic(self, style, italic):
        """Set a style to be italic or not."""
        pass

01325     def StyleSetSize(self, style, sizePoints):
        """Set the size of characters of a style."""
        pass

01329     def StyleSetSpec(self, styleNum, spec):
        """Extract style settings from a spec-string which is composed
        of one or more of the following comma separated elements:

        bold             turns on bold
        italic           turns on italics
        fore:#RRGGBB     sets the foreground colour
        back:#RRGGBB     sets the background colour
        face:[facename]  sets the font face name to use
        size:[num]       sets the font size in points
        eol              turns on eol filling
        underline        turns on underlining
        """
        pass

01344     def StyleSetUnderline(self, style, underline):
        """Set a style to be underlined or not."""
        pass

01348     def StyleSetVisible(self, style, visible):
        """Set a style to be visible or not."""
        pass

01352     def TextHeight(self, line):
        """Return the height of a particular line of text in pixels."""
        pass

01356     def TextWidth(self, style, text):
        """Measure the pixel width of some text in a particular style.
        Nul terminated text argument.  Does not handle tab or control
        characters."""
        pass

01362     def ToggleFold(self, line):
        """Switch a header line between expanded and contracted."""
        pass

01366     def Undo(self):
        """Undo one action in the undo history."""
        pass

01370     def UsePopUp(self, allowPopUp):
        """Set whether a pop up menu is displayed automatically when
        the user presses the wrong mouse button."""
        pass

01375     def UserListShow(self, listType, itemList):
        """Display a list of strings and send notification when user
        chooses one."""
        pass

01380     def VisibleFromDocLine(self, line):
        """Find the display line of a document line taking hidden
        lines into account."""
        pass

01385     def WordEndPosition(self, pos, onlyWordCharacters):
        """Return position of end of word."""
        pass

01389     def WordPartLeft(self):
        """Move to the previous change in capitalisation."""
        pass

01393     def WordPartLeftExtend(self):
        """Move to the previous change in capitalisation extending
        selection to new caret position."""
        pass

01398     def WordPartRight(self):
        """Move to the change next in capitalisation."""
        pass

01402     def WordPartRightExtend(self):
        """Move to the next change in capitalisation extending
        selection to new caret position."""
        pass

01407     def WordStartPosition(self, pos, onlyWordCharacters):
        """Return position of start of word."""
        pass

Generated by  Doxygen 1.6.0   Back to index