dymokomi/luce-ui
Source of release 0.19.5
0.19.5 / src / widgets / text_editor / events.lucb
#==============================================================================================
#
# widgets/text_editor/events - Keys and pointer gestures turned into edits and selections
#
#==============================================================================================
extend TextEditor:
pub func event(event: Event) -> interop.Outcome[unit]:
# Passive hover is derived by Layout and rendered without remeasuring
# controls or rebuilding text projections for each pointer movement. The
# pointer turns into a hand over a color chip, updated only on a transition.
# Resting on a diagnostic starts its tooltip's wait.
if event.kind == input.EventKind.pointer_moved and not event.cancelled and not self.dragging and not self.dragging_scroll:
let over = self.swatch_at(event.x, event.y) >= 0
if over != self.swatch_hover:
self.swatch_hover = over
self.box.value().set_cursor(input.Cursor.pointer if over else input.Cursor.text)
self.rest_pointer(event.x, event.y)
return result.success[unit](())
# Anything else (a press, a key, a scroll, the pointer leaving) ends a tooltip.
self.forget_tip()
let before = self.document.version()
self.handle(event) catch failure:
return result.failure[unit](failure.code, failure.message)
self.box.value().repaint()
if self.pending_swatch >= 0:
let offset = self.pending_swatch
self.pending_swatch = -1
return self.swatch_activated.emit(offset)
if self.document.version() != before:
let changed = self.notify_changed()
if not changed.is_success():
return changed
changed.release()
if event.kind == input.EventKind.focus_lost:
let told = self.unfocused.emit(())
if not told.is_success():
return told
told.release()
# Completion follows the edit only once on_change has heard of it.
self.follow_completion() catch failure:
return result.failure[unit](failure.code, failure.message)
return result.success[unit](())
func handle(event: Event) -> !:
try self.refresh_view()
# A press anywhere in the editor, or losing focus, ends a completion session.
if event.cancelled or event.kind == input.EventKind.focus_lost or event.kind == input.EventKind.pointer_down:
self.end_completion()
if event.cancelled:
self.dragging = false
self.dragging_scroll = false
return
if event.kind == input.EventKind.pointer_down and event.button == 1:
let position = self.position_at(event.x, event.y)
if position < self.document.first() or position >= self.document.last():
try self.set_selection((i64)position, (i64)position)
return
if event.kind == input.EventKind.scroll:
if not math.is_finite(event.scroll_x) or not math.is_finite(event.scroll_y):
error(result.invalid, "scroll deltas must be finite")
let x_scale = self.font.value().advance() * 3.0 if event.scroll_unit == input.ScrollUnit.lines else 1.0
let y_scale = self.font.value().line_height() * 3.0 if event.scroll_unit == input.ScrollUnit.lines else 1.0
self.scroll_y -= event.scroll_y * y_scale
self.scroll_x -= event.scroll_x * x_scale
self.clamp_scroll()
return
if event.kind == input.EventKind.pointer_down and event.button == 0:
let chip = self.swatch_at(event.x, event.y)
if chip >= 0:
self.pending_swatch = chip
return
if self.folds.values().length > 0 and event.x >= self.gutter_width() - self.font.value().advance() * 2.0 and event.x < self.gutter_width():
let visible = (usize)(math.max(0.0, event.y - drawing.vertical_padding(self.font) + self.scroll_y) / self.font.value().line_height())
if visible < self.projection.visible_count():
_ = try self.toggle_fold((i64)self.projection.physical_row(visible) + 1)
return
self.dragging_scroll = event.x >= self.box.value().bounds().width - 10.0
self.dragging = not self.dragging_scroll
if self.dragging_scroll:
self.scroll_to_pointer(event.y)
else:
let position = self.position_at(event.x, event.y)
let now = time.now()
self.clicks = self.clicks + 1 if now - self.last_click < 400000000 and position == self.last_offset and not event.shift else 1
self.last_click = now
self.last_offset = position
if self.clicks >= 2:
try editing.select_word(&self.document, position)
self.dragging = false
else:
try self.document.select(self.document.anchor() if event.shift else position, position)
self.active_since = time.now()
self.vertical_move = false
return
if event.kind == input.EventKind.pointer_moved:
if self.dragging_scroll:
self.scroll_to_pointer(event.y)
elif self.dragging:
if event.y < 0.0:
self.scroll_y = math.max(0.0, self.scroll_y - self.font.value().line_height())
if event.y > self.box.value().bounds().height:
self.scroll_y = math.min(self.maximum_scroll(), self.scroll_y + self.font.value().line_height())
try self.document.select(self.document.anchor(), self.position_at(event.x, event.y))
return
if event.kind == input.EventKind.pointer_up and event.button == 0:
self.dragging = false
self.dragging_scroll = false
return
if event.kind == input.EventKind.text_input and not self.read_only:
# The space a Ctrl+Space press may also type is not text.
if self.swallow_space and event.codepoint == 32:
self.swallow_space = false
return
var bytes: u8[4]
let count = utf8.encode((u32)event.codepoint, bytes) else error(result.invalid, "text input is not a Unicode scalar")
try self.document.insert((str)bytes[..<count])
self.completion_typed((u32)event.codepoint)
return
if event.kind != input.EventKind.key_down:
return
if try self.completion_key(event):
return
try self.key(event)
self.active_since = time.now()
try self.reveal_caret()
func key(event: Event) -> !:
let command = (event.control and not event.alt) or event.meta
if command:
if event.key == input.Key.a:
try self.document.select(0, self.document.length())
return
if event.key == input.Key.c or (event.key == input.Key.x and not self.read_only):
if self.document.first() != self.document.last():
let text = try self.selected_text()
defer text.release()
clipboard.write_text(text.value) catch failure:
if failure.code != window.unsupported:
error(failure.code, failure.message)
return
if event.key == input.Key.x:
try self.document.insert("")
return
if event.key == input.Key.v and not self.read_only:
let text = clipboard.read_text() catch failure:
if failure.code != window.unsupported:
error(failure.code, failure.message)
return
defer text.release()
let normalized = try editing.normalize_lines(text.value)
defer normalized.release()
try self.document.insert(normalized.value)
return
if event.key == input.Key.z and not self.read_only:
_ = try self.document.redo() if event.shift else try self.document.undo()
return
if event.key == input.Key.y and not self.read_only:
_ = try self.document.redo()
return
let caret = self.document.caret()
let extend = event.shift
if event.key == input.Key.left:
let next = self.document.line_start(caret) if event.meta else (editing.word_left(&self.document, caret) if command or event.alt else (caret - 1 if caret > 0 else 0))
try editing.move(&self.document, self.document.first() if not extend and self.document.first() != self.document.last() else next, extend)
elif event.key == input.Key.right:
let next = self.document.line_end(caret) if event.meta else (editing.word_right(&self.document, caret) if command or event.alt else (caret + 1 if caret < self.document.length() else caret))
try editing.move(&self.document, self.document.last() if not extend and self.document.first() != self.document.last() else next, extend)
elif event.key == input.Key.home:
try editing.move(&self.document, 0 if command else self.document.line_start(caret), extend)
elif event.key == input.Key.end:
try editing.move(&self.document, self.document.length() if command else self.document.line_end(caret), extend)
elif event.key == input.Key.up or event.key == input.Key.down or event.key == input.Key.page_up or event.key == input.Key.page_down:
if not self.vertical_move:
let here = self.projection.row(self.projection.visual_row(caret))
self.preferred_column = editing.column(&self.document, caret, self.active_swatches()) - here.column
let row = self.projection.visual_row(caret)
let page = (usize)math.max(1.0, self.box.value().bounds().height / self.font.value().line_height() - 1.0)
let step = page if event.key == input.Key.page_up or event.key == input.Key.page_down else 1
let upwards = event.key == input.Key.up or event.key == input.Key.page_up
let rows = self.projection.visible_count()
let raw = row - step if upwards and row >= step else (0 if upwards else row + step)
let target = self.projection.row(raw if raw < rows else (rows - 1 if rows > 0 else 0))
var offset = editing.at_column(&self.document, self.projection.line(target.physical).start, target.column + self.preferred_column, self.active_swatches())
if offset > target.end:
offset = target.end
if offset < target.start:
offset = target.start
try editing.move(&self.document, offset, extend)
self.vertical_move = true
return
elif not self.read_only:
if event.key == input.Key.backspace or event.key == input.Key.delete:
if self.document.first() == self.document.last():
for fold in self.folds.values():
if fold.collapsed and ((event.key == input.Key.delete and caret + 1 == fold.hidden) or (event.key == input.Key.backspace and caret == fold.end)):
_ = self.folds.set(fold.header, false)
try self.finish_folding()
return
try editing.erase(&self.document, event.key == input.Key.backspace, command or event.alt)
elif event.key == input.Key.enter and not command:
try editing.newline(&self.document)
elif event.key == input.Key.tab:
try editing.indent(&self.document, event.shift)
self.vertical_move = false
func position_at(x: f64, y: f64) -> usize:
let rows = self.projection.visible_count()
let raw = (usize)(math.max(0.0, y - drawing.vertical_padding(self.font) + self.scroll_y) / self.font.value().line_height())
let segment = self.projection.row(raw if raw < rows else (rows - 1 if rows > 0 else 0))
let cells = math.max(0.0, x - self.gutter_width() - self.font.value().advance() + self.scroll_x) / self.font.value().advance()
var offset = editing.at_x(&self.document, self.projection.line(segment.physical).start, (f64)segment.column + cells, self.active_swatches())
if offset > segment.end:
offset = segment.end
if offset < segment.start:
offset = segment.start
return offset