package core:text/edit

Source

Command :: enum u32 {
	None, 
	Undo, 
	Redo, 
	New_Line,          // multi-lines
	Cut, 
	Copy, 
	Paste, 
	Select_All, 
	Backspace, 
	Delete, 
	Delete_Word_Left, 
	Delete_Word_Right, 
	Left, 
	Right, 
	Up,                // multi-lines
	Down,              // multi-lines
	Word_Left, 
	Word_Right, 
	Start, 
	End, 
	Line_Start, 
	Line_End, 
	Select_Left, 
	Select_Right, 
	Select_Up,         // multi-lines
	Select_Down,       // multi-lines
	Select_Word_Left, 
	Select_Word_Right, 
	Select_Start, 
	Select_End, 
	Select_Line_Start, 
	Select_Line_End, 
}

Command_Set :: distinct bit_set[Command; u32]

State :: struct {
	selection:             [2]int,
	line_start:            int,
	line_end:              int,
	// initialized each "frame" with `begin`
	builder:               ^strings.Builder,
	// let the caller store the text buffer data
	up_index:              int,
	down_index:            int,
	// multi-lines
	translate_by_grapheme: bool,
	// undo
	undo:                  [dynamic]^Undo_State,
	redo:                  [dynamic]^Undo_State,
	undo_text_allocator:   runtime.Allocator,
	id:                    u64,
	// Timeout information
	current_time:          time.Tick,
	last_edit_time:        time.Tick,
	undo_timeout:          time.Duration,
	// Set these if you want cut/copy/paste functionality
	set_clipboard:         proc(user_data: rawptr, text: string) -> (ok: bool),
	get_clipboard:         proc(user_data: rawptr) -> (text: string, ok: bool),
	clipboard_user_data:   rawptr,
}

Translation :: enum u32 {
	Start, 
	End, 
	Left, 
	Right, 
	Up, 
	Down, 
	Word_Left, 
	Word_Right, 
	Word_Start, 
	Word_End, 
	Soft_Line_Start, 
	Soft_Line_End, 
}

Undo_State :: struct {
	selection: [2]int,
	len:       int,
	text:      [0]u8,
}

DEFAULT_UNDO_TIMEOUT: time.Duration : 300 * time.Millisecond

MULTILINE_COMMANDS :: Command_Set{.New_Line, .Up, .Down, .Select_Up, .Select_Down}

begin :: proc(s: ^State, id: u64, builder: ^strings.Builder) {…}

clear_all :: proc(s: ^State) -> (cleared: bool) {…}

copy :: proc(s: ^State) -> bool {…}

current_selected_text :: proc(s: ^State) -> string {…}

cut :: proc(s: ^State) -> bool {…}

delete_to :: proc(s: ^State, t: Translation) {…}

destroy :: proc(s: ^State) {…}

end :: proc(s: ^State) {…}

has_selection :: proc(s: ^State) -> bool {…}

init :: proc(
	s:                                         ^State, 
	undo_text_allocator, undo_state_allocator: runtime.Allocator, 
	undo_timeout:                              time.Duration = DEFAULT_UNDO_TIMEOUT, 
) {…}

input_rune :: proc(s: ^State, r: rune) {…}

input_runes :: proc(s: ^State, text: []rune) {…}

input_text :: proc(s: ^State, text: string) -> int {…}

insert :: proc(s: ^State, at: int, text: string) -> int {…}

is_continuation_byte :: proc(b: u8) -> bool {…}

move_to :: proc(s: ^State, t: Translation) {…}

paste :: proc(s: ^State) -> bool {…}

perform_command :: proc(s: ^State, cmd: Command) {…}

remove :: proc(s: ^State, lo, hi: int) {…}

select_to :: proc(s: ^State, t: Translation) {…}

selection_delete :: proc(s: ^State) {…}

setup_once :: proc(s: ^State, builder: ^strings.Builder) {…}

sorted_selection :: proc(s: ^State) -> (lo, hi: int) {…}

translate_position :: proc(s: ^State, t: Translation) -> int {…}

undo :: proc(s: ^State, undo, redo: ^[dynamic]^Undo_State) {…}

undo_check :: proc(s: ^State) {…}

undo_clear :: proc(s: ^State, undo: ^[dynamic]^Undo_State) {…}

undo_state_push :: proc(s: ^State, undo: ^[dynamic]^Undo_State) -> runtime.Allocator_Error {…}

update_time :: proc(s: ^State) {…}