Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.4

0.19.4 / src / widgets / text_editor / module.lucb

#==============================================================================================
#
#   widgets/text_editor/module - The TextEditor widget: its state, lifetime and type
#
#==============================================================================================
#
#   DESCRIPTION:
#       A multiline code editor with highlighting, color chips, folding, soft wrap,
#       change bars, diagnostics, completion and hover. The TextEditor's methods are split by
#       concern across the fragments, each under `extend TextEditor:`. In ORDER:
#
#       module.lucb       the struct, construction, closing and the widget type
#       commands.lucb     the text, selection and edit commands; change notification
#       events.lucb       keys and pointer gestures turned into edits and selections
#       decorations.lucb  highlights, color chips, folds, change bars and AI lines
#       diagnostics.lucb  diagnostic underlines and gutter marks, and their tooltip
#       completion.lucb   the completion provider, its popup, keys and accepting
#       hover.lucb        the hover provider's tooltip over a word
#       view.lucb         layout and drawing: projection, scrolling, wrap, painting
#
#==============================================================================================

from luce_clipboard import clipboard
from luce_gpu import gpu
from luce_window import input
import interop
from luce_std import math
import memory
import ownership
import time
from luce_color import transfer
from luce_std import utf8
from luce_window import window
import layout
import result
import text.drawing
import text.editing
from text.decorations import Decorations
from text.swatches import Swatches
from text.folding import FoldRange, Folding
from text.projection import Projection
from text.diff import LineDiff
from text.diagnostics import Diagnostic, Diagnostics
import text.diagnostic_drawing as diagnostic_drawing
from widgets.tooltip import Tooltip, tooltip_type
from widgets.completion_popup import CompletionPopup, completion_popup_type, completion_rows
from text.completions import CompletionList, CompletionTrigger, completion_list_type
from font import Font, selected_font
from layout import Widget, Layout, Size, Constraints, Event, Point
from painter import Painter
from text.document import Document, TextChange
from text.style import Highlight, EditorTheme, Swatch, swatch_span, hex_digit

## A reusable multiline editor. Its document owns text and history; the widget
## owns focus, selection gestures, scrolling, drawing and application signals.
pub struct TextEditor: Widget:
    let box: interop.Reference[Layout]
    var document: Document
    let changed: interop.Signal[unit]
    let read_only: bool
    let line_numbers: bool
    let font: interop.Reference[Font]
    let theme: EditorTheme?
    var highlights: Decorations
    var swatches: Swatches
    var folds: Folding
    var projection: Projection
    var scroll_x: f64
    var scroll_y: f64
    var dragging: bool
    var dragging_scroll: bool
    var preferred_column: usize
    var vertical_move: bool
    var active_since: u64
    var last_click: u64
    var last_offset: usize
    var clicks: i64
    var ai_first: i64 = 0
    var ai_last: i64 = 0
    var wrap: bool
    var baseline: interop.Owned[str]?
    var diff: LineDiff
    var diff_version: i64
    let swatch_activated: interop.Signal[i64]
    var swatch_hover: bool
    var pending_swatch: i64
    var diagnostics: Diagnostics
    ## The diagnostic tooltip, a popup child; emptied in close before its release.
    var tip: interop.Reference[Tooltip]?
    ## What the pointer rests on: a visual row (-1 for nothing), the first
    ## diagnostic it touches there (-1 for a gutter mark, -2 for a word to hover),
    ## the pointer's x, and since when.
    var tip_row: i64
    var tip_first: i64
    var tip_x: f64
    var tip_since: u64
    var tip_delay: u64
    ## The hovered word's start and the scalar under the pointer (-1 for none), and
    ## whether the hover provider was asked about them already.
    var tip_word: i64
    var tip_offset: i64
    var tip_asked: bool
    ## The providers; each slot is emptied before its callback is released.
    var completer: interop.Callback[interop.Reference[CompletionList], unit]?
    var hover: interop.Callback[i64, str]?
    ## The list handed to the completion provider and the popup showing it, a
    ## popup child; both emptied in close before their release.
    var completions: interop.Reference[CompletionList]?
    var suggestions: interop.Reference[CompletionPopup]?
    ## A completion session: whether one is open, whether Escape hid its popup,
    ## where the replaced word starts, the caret when the provider ran, and the
    ## version and caret last filtered for.
    var completing: bool
    var completion_hidden: bool
    var completion_start: usize
    var completion_origin: usize
    var completion_version: u64
    var completion_caret: usize
    ## The request the event being handled makes, made once it is handled.
    var completion_request: CompletionTrigger?
    ## Ctrl+Space was pressed: a space typed by the same press is not text.
    var swallow_space: bool

    pub func init(text: str = "", read_only: bool = false, line_numbers: bool = true,
                  font: interop.Reference[Font]? = none, theme: EditorTheme? = none, wrap: bool = false) -> !:
        var selected = try selected_font(font)
        errdefer selected.release()
        let box = try layout.make_layout()
        errdefer box.release()
        try box.value().set_limits(Size(120.0, 60.0), Size(16384.0, 16384.0))
        try box.value().set_flex()
        box.value().set_focusable(true)
        # It scrolls itself: the wheel over it is its own, inside a scroll view too.
        box.value().set_takes_scroll(true)
        box.value().set_cursor(input.Cursor.text)
        box.value().set_text_input(not read_only, tabs = not read_only)
        let normalized = try editing.normalize_lines(text)
        defer normalized.release()
        var document = try Document(normalized.value)
        errdefer document.close()
        let changed = try interop.Signal[unit]()
        errdefer changed.release()
        let swatch_activated = try interop.Signal[i64]()
        errdefer swatch_activated.release()
        let tip = try interop.Reference[Tooltip].adopt(new Tooltip(selected) in memory.heap, tooltip_type, memory.heap)
        errdefer tip.release()
        let completions = try interop.Reference[CompletionList].adopt(new CompletionList() in memory.heap, completion_list_type, memory.heap)
        errdefer completions.release()
        let suggestions = try interop.Reference[CompletionPopup].adopt(new CompletionPopup(completions, selected) in memory.heap, completion_popup_type, memory.heap)
        errdefer suggestions.release()
        let children: interop.Interface[Widget][2] = [tip.as_interface[Widget](tip.value()), suggestions.as_interface[Widget](suggestions.value())]
        box.value().set_children(children) catch failure:
            children[0].release()
            children[1].release()
            error(failure.code, failure.message)
        # The layout retained its children; these carriers were ours to drop.
        children[0].release()
        children[1].release()
        let highlights = Decorations()
        let swatches = Swatches()
        var folds = Folding()
        var projection = Projection()
        try projection.refresh(&document, &folds)
        errdefer projection.close()
        self.box = box
        self.document = document
        self.changed = changed
        self.read_only = read_only
        self.line_numbers = line_numbers
        self.font = selected
        self.theme = theme
        self.highlights = highlights
        self.swatches = swatches
        self.folds = folds
        self.projection = projection
        self.scroll_x = 0.0
        self.scroll_y = 0.0
        self.dragging = false
        self.dragging_scroll = false
        self.preferred_column = 0
        self.vertical_move = false
        self.active_since = time.now()
        self.last_click = 0
        self.last_offset = 0
        self.clicks = 0
        self.ai_first = 0
        self.ai_last = 0
        self.wrap = wrap
        self.baseline = none
        self.diff = LineDiff()
        self.diff_version = -1
        self.swatch_activated = swatch_activated
        self.swatch_hover = false
        self.pending_swatch = -1
        self.diagnostics = Diagnostics()
        self.tip = tip
        self.tip_row = -1
        self.tip_first = -1
        self.tip_x = 0.0
        self.tip_since = 0
        self.tip_delay = tip_wait
        self.tip_word = -1
        self.tip_offset = -1
        self.tip_asked = false
        self.completer = none
        self.hover = none
        self.completions = completions
        self.suggestions = suggestions
        self.completing = false
        self.completion_hidden = false
        self.completion_start = 0
        self.completion_origin = 0
        self.completion_version = 0
        self.completion_caret = 0
        self.completion_request = none
        self.swallow_space = false

    pub func layout() -> interop.Reference[Layout]:
        return self.box.clone()

    pub func close():
        self.font.release()
        self.changed.close()
        self.changed.release()
        self.swatch_activated.close()
        self.swatch_activated.release()
        self.document.close()
        self.highlights.close()
        self.swatches.close()
        self.folds.close()
        self.projection.close()
        if let baseline = self.baseline:
            baseline.release()
        self.diff.close()
        self.diagnostics.close()
        let tip = self.tip
        self.tip = none
        if let held = tip:
            held.release()
        let completer = self.completer
        self.completer = none
        if let held = completer:
            held.release()
        let hover = self.hover
        self.hover = none
        if let held = hover:
            held.release()
        let suggestions = self.suggestions
        self.suggestions = none
        if let held = suggestions:
            held.release()
        let completions = self.completions
        self.completions = none
        if let held = completions:
            held.release()
        self.box.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.font.trace(visit, context)
        self.box.trace(visit, context)
        self.changed.trace(visit, context)
        self.swatch_activated.trace(visit, context)
        if let tip = self.tip:
            tip.trace(visit, context)
        if let completer = self.completer:
            completer.trace(visit, context)
        if let hover = self.hover:
            hover.trace(visit, context)
        if let completions = self.completions:
            completions.trace(visit, context)
        if let suggestions = self.suggestions:
            suggestions.trace(visit, context)

## A diagnostic's tooltip shows after the pointer rests this long on it (nanoseconds), unless set.
let tip_wait: u64 = 500000000

pub let text_editor_type: interop.Type[TextEditor] = interop.Type[TextEditor]("Text editor", TextEditor.close, TextEditor.trace, closeable = true, main_thread = true)