Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.1

0.19.1 / src / widgets / text_field.lucb

## The TextField widget: a single-line editable text well.
from luce_gpu import gpu
import interop
from luce_std import math
import ownership
import layout
import result
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from text.line_input import LineInput
from luce_window import input
from font import Font, selected_font

## A single-line text field after eleusis: a sunken well whose border thickens in
## the focus color, text inset by one cell, everything selected on focus, and a
## commit on Enter or on losing focus (`on_commit`); Escape puts the committed
## text back. `on_change` fires on every edit. An empty field shows its
## `placeholder` in the muted color. `on_submit` fires on every Enter, changed or
## not, for a field whose Enter is an action (an address bar loads the page again). A `secure` field (a password) shows bullets
## and refuses copy and cut.
pub struct TextField: Widget:
    let box: interop.Reference[Layout]
    let font: interop.Reference[Font]
    var input: LineInput
    var committed: interop.Owned[str]
    var placeholder: interop.Owned[str]
    var cells: f64
    let changed: interop.Signal[str]
    let submitted: interop.Signal[str]
    let entered: interop.Signal[str]

    ## `cells` is the width the field asks for, in character cells.
    pub func init(text: str = "", font: interop.Reference[Font]? = none, placeholder: str = "", cells: f64 = 12.0,
                  secure: bool = false) -> !:
        var selected = try selected_font(font)
        errdefer selected.release()
        let box = try layout.make_layout()
        errdefer box.release()
        try box.value().set_shrink(vertical = 0.0)
        box.value().set_focusable(true)
        box.value().set_text_input(true)
        box.value().set_cursor(input.Cursor.text)
        var line = try LineInput()
        errdefer line.close()
        line.masked = secure
        try line.set_text(text)
        let changed = try interop.Signal[str]()
        errdefer changed.release()
        let submitted = try interop.Signal[str]()
        errdefer submitted.release()
        let entered = try interop.Signal[str]()
        errdefer entered.release()
        self.committed = try interop.copy_text(text)
        self.placeholder = try interop.copy_text(placeholder)
        self.box = box
        self.font = selected
        self.input = line
        self.cells = math.clamp(cells, 2.0, 120.0)
        self.changed = changed
        self.submitted = submitted
        self.entered = entered

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

    ## The text as edited so far.
    pub func text() -> interop.Owned[str]!:
        return try self.input.text()

    ## Set the text from code and take it as committed; no signals.
    pub func set_text(text: str) -> !:
        try self.input.set_text(text)
        let replacement = try interop.copy_text(text)
        let previous_committed = self.committed
        self.committed = replacement
        previous_committed.release()
        self.box.value().invalidate()

    ## Select the whole text, as Cmd/Ctrl+A does; an address bar does it on focus so
    ## typing replaces the address.
    pub func select_all() -> !:
        try self.input.select_all()
        self.box.value().invalidate()

    ## Called with the whole text after each edit that changes it.
    pub func on_change(callback: interop.Callback[str, unit]) -> interop.Reference[interop.Connection]!:
        return try self.changed.connect(callback)

    ## Called with the text on Enter or focus loss, only when it differs from the
    ## last committed text.
    pub func on_commit(callback: interop.Callback[str, unit]) -> interop.Reference[interop.Connection]!:
        return try self.submitted.connect(callback)

    ## Called with the text on every Enter, after `on_commit` (which only fires when
    ## the text changed): an address field loads its address even when it is the same.
    pub func on_submit(callback: interop.Callback[str, unit]) -> interop.Reference[interop.Connection]!:
        return try self.entered.connect(callback)

    ## Enter: commit the text, then submit it.
    func submit() -> interop.Outcome[unit]:
        let committed = self.commit()
        if not committed.is_success():
            return committed
        committed.release()
        let current = self.input.text() catch failure:
            return result.failure[unit](failure.code, failure.message)
        defer current.release()
        return self.entered.emit(current.value)

    func commit() -> interop.Outcome[unit]:
        let current = self.input.text() catch failure:
            return result.failure[unit](failure.code, failure.message)
        defer current.release()
        if current.value == self.committed.value:
            return result.success[unit](())
        let replacement = interop.copy_text(current.value) catch failure:
            return result.failure[unit](failure.code, failure.message)
        let previous_committed = self.committed
        self.committed = replacement
        previous_committed.release()
        self.box.value().invalidate()
        return self.submitted.emit(current.value)

    func revert() -> interop.Outcome[unit]:
        self.input.set_text(self.committed.value) catch failure:
            return result.failure[unit](failure.code, failure.message)
        self.box.value().invalidate()
        return result.success[unit](())

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        return result.success[Size](Size(self.font.value().advance() * self.cells, self.box.value().theme().row_height(self.font)))

    pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
        self.paint(target) catch failure:
            return result.failure[unit](failure.code, failure.message)
        return result.success[unit](())

    func paint(target: interop.View[gpu.RenderTarget]) -> !:
        var painter = try Painter(target)
        defer painter.close()
        let size = try target.get().size()
        let theme = self.box.value().theme()
        let focused = self.box.value().is_focused()
        let radius = theme.control_radius
        let border = theme.active_border if focused else (theme.hover_border() if self.box.value().contains_pointer() else theme.border)
        let thickness = 2.0 if focused else 1.0
        try painter.rounded_rectangle(gpu.Rect(width = size.width, height = size.height), border, radius)
        try painter.rounded_rectangle(gpu.Rect(thickness, thickness, size.width - thickness * 2.0, size.height - thickness * 2.0), theme.sunken, math.max(0.0, radius - thickness))
        let inset = self.font.value().advance() * 0.75
        let text_y = math.max(0.0, (size.height - self.font.value().height()) * 0.5)
        let current = try self.input.text()
        defer current.release()
        if current.value.length == 0 and not focused and self.placeholder.value.length > 0:
            try painter.text(self.placeholder.value, inset, text_y, color = theme.muted, font = self.font)
        elif focused:
            try self.input.paint(&painter, self.font, theme, inset, text_y, size.width - inset * 2.0)
        else:
            let shown = try self.input.shown_text()
            defer shown.release()
            try painter.text(shown.value, inset, text_y, color = theme.foreground if self.box.value().is_enabled() else theme.muted, font = self.font)

    pub func event(event: Event) -> interop.Outcome[unit]:
        if event.cancelled:
            return self.revert()
        if not self.box.value().is_enabled():
            return result.success[unit](())
        let bounds = self.box.value().bounds()
        let inset = self.font.value().advance() * 0.75
        if event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
            let was_focused = self.box.value().is_focused()
            self.box.value().request_focus()
            if not was_focused:
                # Focus selects everything, Finder-rename style; a second click places the caret.
                let current = self.input.text() catch failure:
                    return result.failure[unit](failure.code, failure.message)
                defer current.release()
                self.input.set_text(current.value) catch failure:
                    return result.failure[unit](failure.code, failure.message)
                self.box.value().invalidate()
                return result.success[unit](())
        if event.kind == input.EventKind.pointer_down or event.kind == input.EventKind.pointer_moved or event.kind == input.EventKind.pointer_up:
            self.input.pointer(event, self.font, inset, 0.0, bounds.width - inset * 2.0, bounds.height) catch failure:
                return result.failure[unit](failure.code, failure.message)
            self.box.value().invalidate()
            return result.success[unit](())
        if event.kind == input.EventKind.focus_lost:
            return self.commit()
        if event.kind == input.EventKind.key_down and event.key == input.Key.escape:
            return self.revert()
        if event.kind == input.EventKind.key_down and event.key == input.Key.enter and not event.repeated:
            return self.submit()
        if event.kind == input.EventKind.key_down or event.kind == input.EventKind.text_input:
            let mutated = self.input.event(event) catch failure:
                return result.failure[unit](failure.code, failure.message)
            if mutated:
                self.box.value().invalidate()
                let current = self.input.text() catch failure:
                    return result.failure[unit](failure.code, failure.message)
                defer current.release()
                return self.changed.emit(current.value)
        return result.success[unit](())

    pub func close():
        self.font.release()
        self.input.close()
        self.changed.close()
        self.changed.release()
        self.submitted.close()
        self.submitted.release()
        self.entered.close()
        self.entered.release()
        self.committed.release()
        self.placeholder.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.submitted.trace(visit, context)
        self.entered.trace(visit, context)
        self.committed.trace(visit, context)
        self.placeholder.trace(visit, context)

pub let text_field_type: interop.Type[TextField] = interop.Type[TextField]("TextField", TextField.close, TextField.trace, closeable = true, main_thread = true)

test "a secure field keeps its text and shows bullets":
    var field = try TextField("pässword", secure = true)
    defer field.close()
    let current = try field.text()
    defer current.release()
    assert(current.value == "pässword")
    let shown = try field.input.shown_text()
    defer shown.release()
    assert(shown.value == "••••••••")
    let part = try field.input.shown(2, 5)
    defer part.release()
    assert(part.value == "•••")

test "a text field holds, resets and commits text":
    var field = try TextField("Layer 2", placeholder = "Name")
    defer field.close()
    let current = try field.text()
    defer current.release()
    assert(current.value == "Layer 2")
    try field.set_text("Background")
    let again = try field.text()
    defer again.release()
    assert(again.value == "Background")