CodeEdit

public CodeEdit();

Creates a code-editor control; add it to a parent with AddChild. Inherits TextEdit, defaults to LTR and disabled folding. Construction does not open a file or connect a compiler/debugger.

public bool AutoBraceCompletionEnabled { get; set; }

Allows automatic closing-key insertion on user opening-key input and paired handling for Backspace/completion confirmation. Configure AutoBraceCompletionPairs. Does not append brackets for every programmatic Text assignment or InsertText call.

public bool AutoBraceCompletionHighlightMatching { get; set; }

Allows visual highlighting of matching braces. Independent of automatic insertion; does not edit Text or validate the whole program.

public Reckfell.Collections.Dictionary AutoBraceCompletionPairs { get; set; }

Maps opening keys to closing keys; both are nonempty strings of symbol/punctuation characters. The setter replaces the set; the getter creates a new Dictionary whose mutation does not change rules. Use AddAutoBraceCompletionPair to add one pair. Does not automatically configure string/comment delimiters.

public bool CodeCompletionEnabled { get; set; }

Enables built-in completion requests during input and through the query shortcut. Does not supply candidates: handle CodeCompletionRequested, add options and call UpdateCodeCompletionOptions. false does not prohibit direct RequestCodeCompletion calls or guarantee closing an active list; use CancelCodeCompletion to close it.

public Reckfell.Collections.Array<string> CodeCompletionPrefixes { get; set; }

Characters allowing completion requests after them, such as a dot. The setter takes only the first code point of each nonempty string, deduplicates and replaces the set. Supply single-character strings. The getter returns a new array; mutating it does not change settings. Result order does not define candidate priority.

public Reckfell.Collections.Array<string> DelimiterComments { get; set; }

Replaces only the comment rules using strings formatted as “start end”, or “start” for an empty end. The getter returns a new array. Serialization does not preserve lineOnly with a nonempty closing key: use AddCommentDelimiter explicitly for such a rule rather than round-tripping the array. Does not configure syntax colors.

public Reckfell.Collections.Array<string> DelimiterStrings { get; set; }

Replaces only the string rules using strings formatted as “start end”, or “start” for an empty end. The getter returns a new array. Serialization does not preserve lineOnly with a nonempty closing key: use AddStringDelimiter explicitly for such a rule rather than round-tripping the array. Does not configure syntax colors.

public bool GuttersDrawBookmarks { get; set; }

Shows bookmarks in the shared main gutter. Does not create bookmarks or clear them when disabled.

public bool GuttersDrawBreakpointsGutter { get; set; }

Shows breakpoint markers in the shared main gutter and enables its clickability for these actions. Does not create breakpoints or connect a debugger. Hiding does not clear markers.

public bool GuttersDrawExecutingLines { get; set; }

Shows execution markers in the shared main gutter. Does not automatically determine the executing line or clear flags when disabled.

public bool GuttersDrawFoldGutter { get; set; }

Shows the folding-button gutter. Does not enable LineFolding or fold lines by itself. May change available text width.

public bool GuttersDrawLineNumbers { get; set; }

Shows logical line numbers starting at one. API indexing remains zero-based; wrapped parts do not become new logical lines. Does not change Text.

public int GuttersLineNumbersMinDigits { get; set; }

Minimum displayed line-number width in digits; use a nonnegative value. The field expands when the final line number needs more digits. Neither a maximum line count nor a change to API indexing.

public bool GuttersZeroPadLineNumbers { get; set; }

Pads displayed line numbers with leading zeroes instead of spaces to the current field width. GuttersLineNumbersMinDigits sets the minimum digit count; document text is unchanged.

public bool IndentAutomatic { get; set; }

Allows automatic indentation on newline input using the current line and IndentAutomaticPrefixes. Does not format the entire document or use a compiler to repair C# structure.

public Reckfell.Collections.Array<string> IndentAutomaticPrefixes { get; set; }

Characters triggering an additional automatic indentation level. Supply nonempty single-character strings: only each first code point is stored. Assignment replaces the set; the getter returns a new array whose mutation does not change settings.

public int IndentSize { get; set; }

Positive indentation step width. The setter also sets inherited TabSize; space indentation uses this many spaces per step. Assignment does not convert existing text: use ConvertIndent.

public bool IndentUseSpaces { get; set; }

Chooses spaces rather than tabs for new indentation. Does not replace existing characters or format the file; ConvertIndent separately converts leading indentation.

public bool LineFolding { get; set; }

Allows logical-line folding. Defaults to false. Disabling reveals all lines; enabling does not fold anything by itself. GuttersDrawFoldGutter separately controls folding icons. Text remains in the document.

public Reckfell.Collections.Array<int> LineLengthGuidelines { get; set; }

Columns for vertical line-length guides. Visual aids rather than an input limit or automatic wrapping. The array is shared; mutating a returned array does not itself request redraw: reassign the property or call QueueRedraw.

public bool SymbolLookupOnClick { get; set; }

Enables lookup requests through a Ctrl/Cmd-modified click. The application validates the current word through SymbolValidate and SetSymbolLookupWordAsValid, then handles SymbolLookup. Does not provide a symbol index or perform navigation. The setter clears the previously validated word.

public bool SymbolTooltipOnHover { get; set; }

Allows a delayed SymbolHovered request when hovering over a word. Does not supply tooltip content; the application prepares it. false stops the pending timer rather than disabling your own symbol provider.

public void AddAutoBraceCompletionPair(string startKey, string endKey);

Adds a pair of nonempty symbol keys, including multi-character keys. An existing opening key cannot be added again; replace the full AutoBraceCompletionPairs mapping to change it. Longer keys are checked before shorter ones. Does not itself edit text or enable automatic insertion.

public void AddCodeCompletionOption(CodeEdit.CodeCompletionKind type, string displayText, string insertText, Color? textColor = default, Resource icon = null, Variant value = default, int location = 1024);

Stages one candidate for the next batch without immediately opening the list. After staging the complete batch, call UpdateCodeCompletionOptions. displayText is shown to the user; insertText is inserted on confirmation; use nonempty strings. type and location describe presentation and ranking rather than executable code. Prefer the Variant value overload: legacy Nullable<Variant> overloads convert null to integer zero rather than nil.

public void AddCodeCompletionOption(CodeEdit.CodeCompletionKind type, string displayText, string insertText, Color? textColor, Resource icon, Variant? value);

Stages one candidate for the next batch without immediately opening the list. After staging the complete batch, call UpdateCodeCompletionOptions. displayText is shown to the user; insertText is inserted on confirmation; use nonempty strings. type and location describe presentation and ranking rather than executable code. Prefer the Variant value overload: legacy Nullable<Variant> overloads convert null to integer zero rather than nil.

public void AddCodeCompletionOption(CodeEdit.CodeCompletionKind type, string displayText, string insertText, Color? textColor, Resource icon, Variant? value, int location);

Stages one candidate for the next batch without immediately opening the list. After staging the complete batch, call UpdateCodeCompletionOptions. displayText is shown to the user; insertText is inserted on confirmation; use nonempty strings. type and location describe presentation and ranking rather than executable code. Prefer the Variant value overload: legacy Nullable<Variant> overloads convert null to integer zero rather than nil.

public void AddCommentDelimiter(string startKey, string endKey, bool lineOnly = false);

Adds a comment delimiter rule for internal editor recognition. startKey is a nonempty symbol key; endKey is a symbol key or empty string, with an empty end forcing lineOnly. Affects commands, folding and context rather than SyntaxHighlighter colors. Check that the same startKey is absent before adding.

public void AddStringDelimiter(string startKey, string endKey, bool lineOnly = false);

Adds a string delimiter rule for internal editor recognition. startKey is a nonempty symbol key; endKey is a symbol key or empty string, with an empty end forcing lineOnly. Affects commands, folding and context rather than SyntaxHighlighter colors. Check that the same startKey is absent before adding.

public bool CanFoldLine(int line);

Tests whether a line can currently fold: requires LineFolding, a nonempty visible header and a suitable block. An already folded header returns false; test IsLineFolded separately. Boundaries use indentation and configured string/comment delimiters or regions rather than a C# compiler AST.

public void CancelCodeCompletion();

Deactivates the completion list and resets forced-display mode. Does not roll back text edits and is not Undo. Does not clear options staged through AddCodeCompletionOption for the next update.

public void ClearBookmarkedLines();

Clears all bookmarks while retaining breakpoint and execution markers. Does not delete document lines.

public void ClearBreakpointedLines();

Clears all breakpoint markers. Emits BreakpointToggled for each currently marked line; repeating with an empty set emits none. Retains other marker types.

public void ClearCommentDelimiters();

Removes all comment rules while retaining the other type. Does not remove matching document text or clear an independent SyntaxHighlighter’s rules.

public void ClearExecutingLines();

Clears all execution markers while retaining bookmarks and breakpoints. Does not affect program execution.

public void ClearStringDelimiters();

Removes all string rules while retaining the other type. Does not remove matching document text or clear an independent SyntaxHighlighter’s rules.

public void ConfirmCodeCompletion(bool replace = false);

Confirms the selected candidate when Editable and the list is active. The built-in implementation applies insert_text at carets in one Undo group: replace true replaces the current section including the remainder to the right, while false attempts to merge matching text to the right. Does not replace the whole document. Then closes the list; a final prefix character may start another request. _ConfirmCodeCompletion replaces insertion after Editable and active-list checks.

public void ConvertIndent(int fromLine = -1, int toLine = -1);

Converts leading indentation in an inclusive range according to IndentUseSpaces/IndentSize. A negative fromLine means the first line; a negative toLine means the last. Skips lines fully classified as string regions; requires Editable. Converting spaces to tabs retains incomplete space groups. Groups changes for Undo; not a full code formatter.

public void CreateCodeRegion();

Surrounds selected line ranges with region markers, attempts folding and selects the first region name for renaming. Requires a selection and a configured single-line comment with an empty end. Inserts two lines per range and removes secondary carets. The direct method does not check Editable: check it before calling. Grouped for Undo.

public void DeleteLines();

Deletes entire selection/caret lines, then clears selections. Deleting the only line leaves an empty one-line document. One Undo group. A direct call does not check Editable; this does not merely delete selected characters.

public void DoIndent();

Calls IndentLines when a selection exists. Otherwise inserts a tab or enough spaces to reach the next indentation step at carets. Requires Editable; an undoable edit command rather than a setting change.

public void DuplicateLines();

Duplicates entire selection/caret line ranges before the originals, adding line separators. Unlike DuplicateSelection, is not limited to selected characters. One Undo group; the direct method does not check Editable.

public void DuplicateSelection();

Duplicates selected text before its start; at carets without selections, duplicates the whole line before the current one. Adjusts positions, unfolds affected blocks and groups changes for Undo. The direct method does not check Editable.

public void FoldAllLines();

Traverses the document top to bottom and folds available headers. Once an outer block folds, its hidden nested headers are not processed separately. Requires LineFolding; retains text but may move carets.

public void FoldLine(int line);

Hides block lines after a header when CanFoldLine is true. Carets in the hidden area collapse to the header end; selections may shrink. Does not delete text or reduce GetLineCount. Does nothing when LineFolding is disabled.

public string GetAutoBraceCompletionCloseKey(string openKey);

Returns the closing key for an exact opening key, or an empty string when absent. Does not insert it.

public Reckfell.Collections.Dictionary GetAutoBraceCompletionPairs();

Maps opening keys to closing keys; both are nonempty strings of symbol/punctuation characters. The setter replaces the set; the getter creates a new Dictionary whose mutation does not change rules. Use AddAutoBraceCompletionPair to add one pair. Does not automatically configure string/comment delimiters.

public Reckfell.Collections.Array<string> GetAutoIndentPrefixes();

Characters triggering an additional automatic indentation level. Supply nonempty single-character strings: only each first code point is stored. Assignment replaces the set; the getter returns a new array whose mutation does not change settings.

public int[] GetBookmarkedLines();

Returns a new int[] of bookmarked line indices in ascending order. A snapshot: mutating the array does not change bookmarks. Reread indices after text edits.

public int[] GetBreakpointedLines();

Returns a new int[] of breakpoint line indices in ascending order. Mutating the array does not change the editor. Indices shift when lines are inserted or removed; they are not persistent identifiers.

public Reckfell.Collections.Dictionary GetCodeCompletionOption(int index);

Returns a new Dictionary record at an index in the current filtered list. Returns an empty record when inactive; validate bounds when active. Keys: kind, display_text, insert_text, font_color, icon, location, default_value. A snapshot rather than an editable option reference; resources and nested values may be shared.

public Reckfell.Collections.Array<Reckfell.Collections.Dictionary> GetCodeCompletionOptions();

Returns the active list’s current filtered options, or an empty Array<Dictionary> when inactive. Each record contains kind, display_text, insert_text, font_color, icon, location, default_value. Containers are newly created: mutating them does not update the list. icon resources and nested default_value objects may retain shared references; this is not a deep copy.

public Reckfell.Collections.Array<string> GetCodeCompletionPrefixes();

Characters allowing completion requests after them, such as a dot. The setter takes only the first code point of each nonempty string, deduplicates and replaces the set. Supply single-character strings. The getter returns a new array; mutating it does not change settings. Result order does not define candidate priority.

public int GetCodeCompletionSelectedIndex();

Returns the selected index in the active filtered list, or -1 when inactive. Not a source-candidate ID: filtering and updates can change ordering.

public string GetCodeRegionEndTag();

Returns the end tag name without the comment prefix.

public string GetCodeRegionStartTag();

Returns the start tag name without the comment prefix rather than the entire marker line.

public Reckfell.Collections.Array<string> GetCommentDelimiters();

Replaces only the comment rules using strings formatted as “start end”, or “start” for an empty end. The getter returns a new array. Serialization does not preserve lineOnly with a nonempty closing key: use AddCommentDelimiter explicitly for such a rule rather than round-tripping the array. Does not configure syntax colors.

public string GetDelimiterEndKey(int delimiterIndex);

Returns the closing key at a current combined delimiter-set index. An empty string may represent a line-only delimiter with no explicit end.

public Vector2 GetDelimiterEndPosition(int line, int column);

Returns a region end boundary as Vector2: X column after the closing key, Y line. A line-only region without a closing key can use line length plus one. An unfound end returns (-1, -1); check it before computing a range. These are not screen pixels.

public string GetDelimiterStartKey(int delimiterIndex);

Returns the opening key at a current index in the combined string/comment delimiter set. Obtain indices from IsInString/IsInComment; rule changes can invalidate them.

public Vector2 GetDelimiterStartPosition(int line, int column);

Returns a recognized region’s start as Vector2: X column, Y line, (-1, -1) when absent. This is an internal cache boundary: X is the opening key’s start plus one code point, not necessarily the first content character for a multi-character key. Do not use X directly as a content-slice boundary without accounting for key length.

public int[] GetExecutingLines();

Returns a new int[] of execution-marker line indices in ascending order. May contain multiple indices. Mutating the array does not change the editor.

public Reckfell.Collections.Array<int> GetFoldedLines();

Returns a new Array<int> of visible folded-header indices in ascending order. Hidden nested headers are excluded. Mutating the array does not change folding; use FoldLine/UnfoldLine.

public int GetIndentSize();

Positive indentation step width. The setter also sets inherited TabSize; space indentation uses this many spaces per step. Assignment does not convert existing text: use ConvertIndent.

public Reckfell.Collections.Array<int> GetLineLengthGuidelines();

Columns for vertical line-length guides. Visual aids rather than an input limit or automatic wrapping. The array is shared; mutating a returned array does not itself request redraw: reassign the property or call QueueRedraw.

public int GetLineNumbersMinDigits();

Minimum displayed line-number width in digits; use a nonnegative value. The field expands when the final line number needs more digits. Neither a maximum line count nor a change to API indexing.

public Reckfell.Collections.Array<string> GetStringDelimiters();

Replaces only the string rules using strings formatted as “start end”, or “start” for an empty end. The getter returns a new array. Serialization does not preserve lineOnly with a nonempty closing key: use AddStringDelimiter explicitly for such a rule rather than round-tripping the array. Does not configure syntax colors.

public string GetTextForCodeCompletion();

Returns the entire text with a U+FFFF marker at caret 0. Context for the application’s analyzer rather than a completion result; Text is unchanged. Columns use Unicode code points. Do not save the service marker in a source file.

public string GetTextForSymbolLookup();

Returns the entire text with U+FFFF at the mouse position rather than the text caret. Returns an empty string when the mouse does not hit text. Provides symbol-resolution context; does not find a definition or open a file.

public string GetTextWithCursorChar(int line, int column);

Returns the entire text with a service U+FFFF at the supplied position without changing Text or the caret. Supply an existing line and a Unicode code-point column from zero through line length. A context snapshot for an analyzer rather than a move or insertion command.

public bool HasAutoBraceCompletionCloseKey(string closeKey);

Tests whether at least one pair has this exact closing key. Does not check document brace balance.

public bool HasAutoBraceCompletionOpenKey(string openKey);

Tests exact opening-key membership in pair settings rather than searching the document.

public bool HasCommentDelimiter(string startKey);

Tests exact startKey membership among comment rules rather than searching document text.

public bool HasStringDelimiter(string startKey);

Tests exact startKey membership among string rules rather than searching document text.

public void IndentLines();

Increases leading indentation of selection/caret lines. Skips completely empty lines; spaces align to the next step, tabs add one tab. Requires Editable and groups changes for Undo.

public bool IsAutoBraceCompletionEnabled();

Allows automatic closing-key insertion on user opening-key input and paired handling for Backspace/completion confirmation. Configure AutoBraceCompletionPairs. Does not append brackets for every programmatic Text assignment or InsertText call.

public bool IsAutoIndentEnabled();

Allows automatic indentation on newline input using the current line and IndentAutomaticPrefixes. Does not format the entire document or use a compiler to repair C# structure.

public bool IsCodeCompletionEnabled();

Enables built-in completion requests during input and through the query shortcut. Does not supply candidates: handle CodeCompletionRequested, add options and call UpdateCodeCompletionOptions. false does not prohibit direct RequestCodeCompletion calls or guarantee closing an active list; use CancelCodeCompletion to close it.

public bool IsDrawLineNumbersEnabled();

Shows logical line numbers starting at one. API indexing remains zero-based; wrapped parts do not become new logical lines. Does not change Text.

public bool IsDrawingBookmarksGutter();

Shows bookmarks in the shared main gutter. Does not create bookmarks or clear them when disabled.

public bool IsDrawingBreakpointsGutter();

Shows breakpoint markers in the shared main gutter and enables its clickability for these actions. Does not create breakpoints or connect a debugger. Hiding does not clear markers.

public bool IsDrawingExecutingLinesGutter();

Shows execution markers in the shared main gutter. Does not automatically determine the executing line or clear flags when disabled.

public bool IsDrawingFoldGutter();

Shows the folding-button gutter. Does not enable LineFolding or fold lines by itself. May change available text width.

public bool IsHighlightMatchingBracesEnabled();

Allows visual highlighting of matching braces. Independent of automatic insertion; does not edit Text or validate the whole program.

public int IsInComment(int line, int column = -1);

Returns a matching rule index in the combined delimiter set, or -1. column -1 tests whole-line coverage excluding edge whitespace rather than the presence of any fragment. Supply a Unicode code-point column for a specific position. Not a bool; compare the result with -1.

public int IsInString(int line, int column = -1);

Returns a matching rule index in the combined delimiter set, or -1. column -1 tests whole-line coverage excluding edge whitespace rather than the presence of any fragment. Supply a Unicode code-point column for a specific position. Not a bool; compare the result with -1.

public bool IsIndentUsingSpaces();

Chooses spaces rather than tabs for new indentation. Does not replace existing characters or format the file; ConvertIndent separately converts leading indentation.

public bool IsLineBookmarked(int line);

Tests an existing line’s bookmark flag independently of gutter visibility.

public bool IsLineBreakpointed(int line);

Tests an existing line’s breakpoint marker. Does not confirm debugger attachment or that execution can stop on that line.

public bool IsLineCodeRegionEnd(int line);

Tests the configured region-end token after trimming edge whitespace; does not validate whole-document pairing or nesting.

public bool IsLineCodeRegionStart(int line);

Tests whether the edge-trimmed line begins with the configured region-start token. A line classified inside a string is excluded. Recognizing one marker does not guarantee a matching end.

public bool IsLineExecuting(int line);

Tests an existing line’s execution marker rather than querying the actual VM/debugger state.

public bool IsLineFolded(int line);

true for a visible header immediately followed by a hidden line. Returns false for a hidden body line: not a general line-visibility test.

public bool IsLineFoldingEnabled();

Allows logical-line folding. Defaults to false. Disabling reveals all lines; enabling does not fold anything by itself. GuttersDrawFoldGutter separately controls folding icons. Text remains in the document.

public bool IsLineNumbersZeroPadded();

Pads displayed line numbers with leading zeroes instead of spaces to the current field width. GuttersLineNumbersMinDigits sets the minimum digit count; document text is unchanged.

public bool IsSymbolLookupOnClickEnabled();

Enables lookup requests through a Ctrl/Cmd-modified click. The application validates the current word through SymbolValidate and SetSymbolLookupWordAsValid, then handles SymbolLookup. Does not provide a symbol index or perform navigation. The setter clears the previously validated word.

public bool IsSymbolTooltipOnHoverEnabled();

Allows a delayed SymbolHovered request when hovering over a word. Does not supply tooltip content; the application prepares it. false stops the pending timer rather than disabling your own symbol provider.

public void JoinLines(string lineEnding = " ");

Joins each affected line to its successor, removing edge whitespace at the join. Inserts lineEnding between nonempty parts; newlines in it are forbidden. Without selection, joins the caret line to the next; a range can include the successor of the last selected line. One Undo group; the direct method does not check Editable.

public void MoveLinesDown();

Moves line ranges one line downward, adjusting carets/selections and unfolding blocks. A range at document end does not move. One Undo group; a direct call does not check Editable.

public void MoveLinesUp();

Moves selection/caret line ranges one line upward, unfolding affected blocks. A range at document start stays in place. Grouped for Undo. A direct call does not check Editable; enforce it in your command handler.

public void RemoveCommentDelimiter(string startKey);

Removes a comment rule by exact startKey and updates recognition caches. Does not edit document text; remaining rule indices may change.

public void RemoveStringDelimiter(string startKey);

Removes a string rule by exact startKey and updates recognition caches. Does not edit document text; remaining rule indices may change.

public void RequestCodeCompletion(bool force = false);

Requests candidates through CodeCompletionRequested for a suitable caret-0 context. force bypasses the ordinary context check but not the guard for an already active homogeneous FilePath/EntityPath/Signal list. Does not create candidates or insert text. Overriding _RequestCodeCompletion replaces the default request and event. A direct call does not test CodeCompletionEnabled.

public void SetAutoBraceCompletionEnabled(bool enable);

Allows automatic closing-key insertion on user opening-key input and paired handling for Backspace/completion confirmation. Configure AutoBraceCompletionPairs. Does not append brackets for every programmatic Text assignment or InsertText call.

public void SetAutoBraceCompletionPairs(Reckfell.Collections.Dictionary pairs);

Maps opening keys to closing keys; both are nonempty strings of symbol/punctuation characters. The setter replaces the set; the getter creates a new Dictionary whose mutation does not change rules. Use AddAutoBraceCompletionPair to add one pair. Does not automatically configure string/comment delimiters.

public void SetAutoIndentEnabled(bool enable);

Allows automatic indentation on newline input using the current line and IndentAutomaticPrefixes. Does not format the entire document or use a compiler to repair C# structure.

public void SetAutoIndentPrefixes(Reckfell.Collections.Array<string> prefixes);

Characters triggering an additional automatic indentation level. Supply nonempty single-character strings: only each first code point is stored. Assignment replaces the set; the getter returns a new array whose mutation does not change settings.

public void SetCodeCompletionEnabled(bool enable);

Enables built-in completion requests during input and through the query shortcut. Does not supply candidates: handle CodeCompletionRequested, add options and call UpdateCodeCompletionOptions. false does not prohibit direct RequestCodeCompletion calls or guarantee closing an active list; use CancelCodeCompletion to close it.

public void SetCodeCompletionPrefixes(Reckfell.Collections.Array<string> prefixes);

Characters allowing completion requests after them, such as a dot. The setter takes only the first code point of each nonempty string, deduplicates and replaces the set. Supply single-character strings. The getter returns a new array; mutating it does not change settings. Result order does not define candidate priority.

public void SetCodeCompletionSelectedIndex(int index);

Selects a valid index in the active filtered list. Does nothing when inactive; -1 is not a close command. Does not insert text: call ConfirmCodeCompletion to confirm.

public void SetCodeHint(string codeHint);

Sets a separate text hint, such as a function signature; an empty string hides it. Does not add a completion option or analyze a function. A pair of U+FFFF markers in a line highlights the span between them; markers are not drawn. Document text is unchanged.

public void SetCodeHintDrawBelow(bool drawBelow);

Positions the SetCodeHint hint below the current line rather than above. Does not itself set hint text or open completion options.

public void SetCodeRegionTags(string start = "region", string end = "endregion");

Sets distinct nonempty region start/end tag names, such as region/endregion. Actual markers concatenate a single-line comment prefix and the tag without adding a space. Configure such a comment first through AddCommentDelimiter with an empty end. Does not rewrite existing document markers.

public void SetCommentDelimiters(Reckfell.Collections.Array<string> commentDelimiters);

Replaces only the comment rules using strings formatted as “start end”, or “start” for an empty end. The getter returns a new array. Serialization does not preserve lineOnly with a nonempty closing key: use AddCommentDelimiter explicitly for such a rule rather than round-tripping the array. Does not configure syntax colors.

public void SetDrawBookmarksGutter(bool enable);

Shows bookmarks in the shared main gutter. Does not create bookmarks or clear them when disabled.

public void SetDrawBreakpointsGutter(bool enable);

Shows breakpoint markers in the shared main gutter and enables its clickability for these actions. Does not create breakpoints or connect a debugger. Hiding does not clear markers.

public void SetDrawExecutingLinesGutter(bool enable);

Shows execution markers in the shared main gutter. Does not automatically determine the executing line or clear flags when disabled.

public void SetDrawFoldGutter(bool enable);

Shows the folding-button gutter. Does not enable LineFolding or fold lines by itself. May change available text width.

public void SetDrawLineNumbers(bool enable);

Shows logical line numbers starting at one. API indexing remains zero-based; wrapped parts do not become new logical lines. Does not change Text.

public void SetHighlightMatchingBracesEnabled(bool enable);

Allows visual highlighting of matching braces. Independent of automatic insertion; does not edit Text or validate the whole program.

public void SetIndentSize(int size);

Positive indentation step width. The setter also sets inherited TabSize; space indentation uses this many spaces per step. Assignment does not convert existing text: use ConvertIndent.

public void SetIndentUsingSpaces(bool useSpaces);

Chooses spaces rather than tabs for new indentation. Does not replace existing characters or format the file; ConvertIndent separately converts leading indentation.

public void SetLineAsBookmarked(int line, bool bookmarked);

Sets or clears a line bookmark while retaining breakpoint and execution markers. Does not move the caret, edit text or create a bookmark file. GuttersDrawBookmarks separately enables its icon.

public void SetLineAsBreakpoint(int line, bool breakpointed);

Sets or clears a line’s breakpoint marker. Every call emits BreakpointToggled, even when the state is unchanged. For idempotent synchronization, compare IsLineBreakpointed first. This is UI state; configure actual program suspension through your debugger.

public void SetLineAsExecuting(int line, bool executing);

Sets or clears a visual execution marker. Multiple lines may be marked; does not run, suspend or step code. The application manages state and clearing. GuttersDrawExecutingLines separately enables the icon.

public void SetLineFoldingEnabled(bool enabled);

Allows logical-line folding. Defaults to false. Disabling reveals all lines; enabling does not fold anything by itself. GuttersDrawFoldGutter separately controls folding icons. Text remains in the document.

public void SetLineLengthGuidelines(Reckfell.Collections.Array<int> guidelineColumns);

Columns for vertical line-length guides. Visual aids rather than an input limit or automatic wrapping. The array is shared; mutating a returned array does not itself request redraw: reassign the property or call QueueRedraw.

public void SetLineNumbersMinDigits(int count);

Minimum displayed line-number width in digits; use a nonnegative value. The field expands when the final line number needs more digits. Neither a maximum line count nor a change to API indexing.

public void SetLineNumbersZeroPadded(bool enable);

Pads displayed line numbers with leading zeroes instead of spaces to the current field width. GuttersLineNumbersMinDigits sets the minimum digit count; document text is unchanged.

public void SetStringDelimiters(Reckfell.Collections.Array<string> stringDelimiters);

Replaces only the string rules using strings formatted as “start end”, or “start” for an empty end. The getter returns a new array. Serialization does not preserve lineOnly with a nonempty closing key: use AddStringDelimiter explicitly for such a rule rather than round-tripping the array. Does not configure syntax colors.

public void SetSymbolLookupOnClickEnabled(bool enable);

Enables lookup requests through a Ctrl/Cmd-modified click. The application validates the current word through SymbolValidate and SetSymbolLookupWordAsValid, then handles SymbolLookup. Does not provide a symbol index or perform navigation. The setter clears the previously validated word.

public void SetSymbolLookupWordAsValid(bool valid);

Accepts or rejects the current pending SymbolValidate word and consumes that pending state. true enables its lookup highlighting/navigation; false clears it. Supplies neither a symbol name nor a definition address: respond to the current request, preferably in its handler.

public void SetSymbolTooltipOnHoverEnabled(bool enable);

Allows a delayed SymbolHovered request when hovering over a word. Does not supply tooltip content; the application prepares it. false stops the pending timer rather than disabling your own symbol provider.

public void ToggleFoldableLine(int line);

Unfolds a folded header or attempts to fold an eligible line. For a hidden body line this is not equivalent to UnfoldLine: call UnfoldLine explicitly. Does not edit text.

public void ToggleFoldableLinesAtCarets();

Toggles folding at caret lines in document order. Multiple carets on one header toggle it once. Folding may merge carets or exclude affected carets from further processing.

public void UnfoldAllLines();

Reveals all hidden blocks while retaining text and the LineFolding setting. Does not restore caret positions previously moved by folding.

public void UnfoldLine(int line);

Reveals the contiguous hidden block after the supplied header; a hidden body line may be supplied to locate its header. Nested folds in the revealed area are also cleared: prior nested-fold state is not preserved. Text is unchanged.

public void UnindentLines();

Reduces indentation of selection/caret lines by removing a leading tab or spaces back to the previous step. Requires Editable; groups edits for Undo. Does not remove arbitrary spaces inside code.

public void UpdateCodeCompletionOptions(bool force);

Replaces the source candidate set with the staged AddCodeCompletionOption queue, clears that queue and filters for the current caret-0 context. Calling again without new candidates submits an empty batch. force relaxes some automatic-display conditions but does not guarantee a visible list with unsuitable context or no matches. Use _FilterCodeCompletionCandidates for a custom filter.

public virtual void _ConfirmCodeCompletion(bool replace);

Overrides selected-option insertion after Editable and active-list checks. Obtain the selected record, perform edits and required Undo grouping, then call CancelCodeCompletion as appropriate. Default insertion and closing do not continue automatically. The base C# method is empty; calling ConfirmCodeCompletion from the handler recurses.

public virtual Reckfell.Collections.Array<Reckfell.Collections.Dictionary> _FilterCodeCompletionCandidates(Reckfell.Collections.Array<Reckfell.Collections.Dictionary> candidates);

Replaces built-in filtering and ranking: return records with the complete GetCodeCompletionOption key set in the required order. An empty result closes the list. The base C# method does not run the default filter. This path resets the completion base: do not assume default confirmation removes a typed prefix as the built-in filter does; use _ConfirmCodeCompletion for custom insertion semantics.

public virtual void _RequestCodeCompletion(bool force);

An override completely replaces default RequestCodeCompletion, including CodeCompletionRequested. Prepare candidates and call UpdateCodeCompletionOptions yourself, or issue your own provider request. The base C# method is empty. Do not call RequestCodeCompletion from the handler to continue: it recurses.

public event CodeEdit.BreakpointToggledEventHandler BreakpointToggled;

Notifies which line’s breakpoint state should be reread with IsLineBreakpointed. A programmatic setter emits it even without a value change. Moving a breakpoint after a text edit can notify both old and new indices; do not treat the event as an unconditional bool toggle. Validate the current line range first: an old index may no longer exist.

public event Action CodeCompletionRequested;

Asks the application to prepare candidates for the current context. Obtain GetTextForCodeCompletion, add options with AddCodeCompletionOption, then call UpdateCodeCompletionOptions once. Each submitted batch replaces the previous one rather than extending it. For an asynchronous response, verify that text and caret context still match: the request has no built-in ID.

public event CodeEdit.SymbolHoveredEventHandler SymbolHovered;

Delayed-hover event with a symbol and its line/column in the current document. Emitted under suitable pointer/input conditions; the application supplies and displays tooltip content. Does not automatically provide a symbol type or documentation.

public event CodeEdit.SymbolLookupEventHandler SymbolLookup;

Asks the application to navigate to a validated symbol’s definition. symbol, line and column describe the clicked location in the current document rather than a definition address. The application resolves the target and opens the file/position.

public event CodeEdit.SymbolValidateEventHandler SymbolValidate;

Asks whether the current word supports navigation. Resolve it with your own system and respond with SetSymbolLookupWordAsValid. Validates a navigation candidate rather than reporting compiler diagnostics. The pending word changes with pointer movement: do not apply a delayed response without checking freshness.