/* * String input and command history buffer routines. * * Copyright (c) 2019 Dr. D'nar * SPDX-License-Identifier: BSD-2-clause */ #include #include #include #include #include #include #include #include #include #include "editor.h" #include "calc.h" #include "style.h" #include "ez80.h" /******************************************************************************* * History circular buffer ******************************************************************************/ #define MAX_HISTORY 256 #define MAX_HISTORY_MASK 255 char** history = NULL; unsigned char history_next = 0; /** * Initializes the command history buffer. * Does nothing if a history buffer already exists. */ void init_history(void) { int i; if (history) return; history = malloc_safe(sizeof(char*) * MAX_HISTORY); for (i = 0; i < MAX_HISTORY; i++) history[i] = NULL; history_next = 0; } /** * Frees the command history buffer. All history is deleted. */ void free_history(void) { int i; if (!history) return; for (i = 0; i < MAX_HISTORY; i++) //if (history[i] != NULL) free(history[i]); free(history); history = NULL; } /** * Adds the given string to the command history. * If the last string added is identical to the one passed, then it is not added * again. */ void add_history(char* string) { char* item; if (!history) return; if (!strcmp(get_history_item(1), string)) return; free(history[history_next]); item = malloc_safe(strlen(string) + 1); strcpy(item, string); history[history_next] = item; /*history_next = (history_next + 1) & MAX_HISTORY_MASK;*/ history_next++; } /** * Gets an item from the history buffer. * @param n How far back to go. 1 means the most recent item. * 0 will either return NULL or the LAST item depending on whether the history * buffer has filled up. */ char* get_history_item(unsigned char n) { /* This saves six bytes . . . eh, why not? */ unsigned char i; if (!history) return NULL; i = history_next - n; /*return history[(history_next + MAX_HISTORY - n) & MAX_HISTORY_MASK];*/ return history[i]; } /******************************************************************************* * Line editor ******************************************************************************/ /* gfx_HorizLine_NoClip(uint24_t x, uint8_t y, uint24_t length); gfx_Rectangle_NoClip(uint24_t x, uint8_t y, uint24_t width, uint8_t height); gfx_FillRectangle_NoClip(uint24_t x, uint8_t y, uint24_t width, uint8_t height); uint8_t gfx_SetColor(uint8_t index); // returns previous color */ /** * Internal routine for making sure FontLibC is set up properly. */ void editor_fontlib_config(editor_context_t* context) { fontlib_SetWindow(context->base_x, context->base_y, context->width, context->font_height); fontlib_SetColors(context->fg_color, context->bg_color); fontlib_SetFont(context->font, 0); fontlib_SetTransparency(false); } /** * Redraws the contents of the editor, also erases any blank space. */ void editor_redraw_from_cursor(editor_context_t* context) { editor_fontlib_config(context); fontlib_SetCursorPosition(context->cursor_x, context->base_y); fontlib_DrawString(context->str + context->cursor_index); fontlib_ClearEOL(); } /** * Redraws the contents of the editor, also erases any blank space. */ void editor_redraw(editor_context_t* context) { editor_fontlib_config(context); fontlib_SetCursorPosition(context->base_x, context->base_y); fontlib_DrawString(context->str); fontlib_ClearEOL(); } /** * Allocates and draws an empty editor session. */ editor_context_t* editor_start(uint24_t x_loc, uint8_t y_loc, uint24_t box_width, uint8_t text_max_length, fontlib_font_t* editor_font) { editor_context_t* context = malloc_safe(sizeof(editor_context_t)); context->base_x = x_loc; context->base_y = y_loc; context->width = box_width; fontlib_SetFont(editor_font, 0); context->font = editor_font; context->font_height = fontlib_GetCurrentFontHeight(); context->fg_color = foreground_color; context->bg_color = background_color; context->cursor_glyph = '\2'; context->cursor_shown = false; context->max_length = text_max_length; context->cursor_index = 0; context->cursor_x = x_loc; context->current_length = 0; context->str = malloc_safe(1 + text_max_length); memset(context->str, '\0', 1 + text_max_length); editor_redraw(context); return context; } /** * Closes the editor context, freeing memory resources and erasing the box. * Note that you also lose your edit buffer! */ void editor_close(editor_context_t* context) { editor_fontlib_config(context); fontlib_SetCursorPosition(context->base_x, context->base_y); fontlib_ClearEOL(); free(context->str); free(context); } /** * Closes the editor context, freeing memory resources and erasing the box. * You must free the edit buffer yourself. */ char* editor_get_string_close(editor_context_t* context) { char* s = context->str; editor_fontlib_config(context); fontlib_SetCursorPosition(context->base_x, context->base_y); fontlib_ClearEOL(); free(context); return s; } /** * Advances the cursor. */ void editor_right(editor_context_t* context) { if (context->cursor_index >= context->current_length) return; context->cursor_x += fontlib_GetGlyphWidth(context->str[context->cursor_index++]); } /** * Moves the cursor back one place. */ void editor_left(editor_context_t* context) { if (context->cursor_index <= 0) return; context->cursor_x -= fontlib_GetGlyphWidth(context->str[--context->cursor_index]); } /** * Moves the cursor back to the start of the edit buffer. */ void editor_home(editor_context_t* context) { editor_cursor_set(context, 0); } /** * Moves the cursor to the end of the edit buffer. */ void editor_end(editor_context_t* context) { editor_cursor_set(context, context->current_length); } /** * Sets the cursor position. */ void editor_cursor_set(editor_context_t* context, uint8_t index) { context->cursor_index = index; if (index == 0) context->cursor_x = context->base_x; else context->cursor_x = context->base_x + fontlib_GetStringWidthL(context->str, index); } /** * Inserts one character into the edit buffer at the current cursor position. */ void editor_insert(editor_context_t* context, char character) { uint8_t i = context->cursor_index; char* s = &context->str[i]; if (context->current_length >= context->max_length) return; memmove(s + 1, s, context->current_length - i + 1); context->str[i] = character; context->current_length++; editor_redraw_from_cursor(context); } /** * Inserts an entire string into the edit buffer at the current cursor position. * If the string is too big, inserts as much as possible. * * Also this method is broken. * void editor_insert_str(editor_context_t* context, char* str) { uint8_t i = context->cursor_index; int str_len = strlen(str); int new_len = context->current_length + str_len; char* s = context->str + i; if (context->current_length == context->max_length) return; if (new_len >= context->max_length) str_len -= new_len - context->max_length; memmove(s + str_len, s, context->current_length - i + 1); memcpy(str, s, str_len); context->current_length += str_len; editor_redraw_from_cursor(context); }*/ /** * Completely replaces the contents of the edit buffer with str. */ void editor_set_str(editor_context_t* context, char* str) { size_t len = strlen(str); if (len > context->max_length) len = context->max_length; memcpy(context->str, str, len); context->str[len + 1] = '\0'; context->current_length = (unsigned char)len; editor_end(context); } /** * Deletes n characters from the edit buffer starting at the current cursor position. */ void editor_delete(editor_context_t* context, uint8_t n) { uint8_t i = context->cursor_index; char* s = context->str + i; if (n >= context->current_length - context->cursor_index) { *s = '\0'; context->current_length = context->cursor_index; return; } memmove(s, s + n, context->current_length - i - n + 1); context->current_length -= n; editor_redraw_from_cursor(context); } /** * Erases the entire contents of the edit buffer. */ void editor_flush(editor_context_t* context) { context->current_length = 0; context->cursor_x = context->base_x; context->cursor_index = 0; context->str[0] = '\0'; editor_fontlib_config(context); fontlib_SetCursorPosition(context->base_x, context->base_y); fontlib_ClearEOL(); } /** * Display a cursor. */ void editor_show_cursor(editor_context_t* context) { if (context->cursor_shown) return; context->cursor_shown = true; editor_fontlib_config(context); fontlib_SetCursorPosition(context->cursor_x, context->base_y); fontlib_DrawGlyph(context->cursor_glyph); } /** * Hides the cursor. */ void editor_hide_cursor(editor_context_t* context) { char* sptr; char* end; unsigned int x_end; if (!context->cursor_shown) return; context->cursor_shown = false; editor_fontlib_config(context); fontlib_SetCursorPosition(context->cursor_x, context->base_y); /* We're going to hide the cursor by redrawing everything until the drawing * cursor is past the right edge of the cursor glyph. */ x_end = context->cursor_x + fontlib_GetGlyphWidth(context->cursor_glyph); sptr = context->str + context->cursor_index; end = context->str + context->current_length; do fontlib_DrawGlyph(*(sptr++)); while (fontlib_GetCursorX() <= x_end && sptr < end); if (sptr >= end) fontlib_ClearEOL(); } /** * Shows the cursor if it's not shown, hides it if it's visible. */ void editor_toggle_cursor(editor_context_t* context) { if (context->cursor_shown) editor_hide_cursor(context); else editor_show_cursor(context); } char key_translation_table[3][0x39] = { { /* Unshifted */ '\0', /* 0 */ '\0', /* sk_Down 0x01 */ '\0', /* sk_Left 0x02 */ '\0', /* sk_Right 0x03 */ '\0', /* sk_Up 0x04 */ '\0', '\0', '\0', '\0', /* 5, 6, 7, 8 */ '\0', /* sk_Enter 0x09 */ '+', /* sk_Add 0x0A */ '-', /* sk_Sub 0x0B */ '*', /* sk_Mul 0x0C */ '/', /* sk_Div 0x0D */ '^', /* sk_Power 0x0E */ '\0', /* sk_Clear 0x0F */ '\0', /* 10 */ '\\', /* sk_Chs 0x11 */ '3', /* sk_3 0x12 */ '6', /* sk_6 0x13 */ '9', /* sk_9 0x14 */ ')', /* sk_RParen 0x15 */ '\0', /* sk_Tan 0x16 */ '\0', /* sk_Vars 0x17 */ '\0', /* 18 */ '.', /* sk_DecPnt 0x19 */ '2', /* sk_2 0x1A */ '5', /* sk_5 0x1B */ '8', /* sk_8 0x1C */ '(', /* sk_LParen 0x1D */ '\0', /* sk_Cos 0x1E */ '\0', /* sk_Prgm 0x1F */ '\0', /* sk_Stat 0x20 */ '0', /* sk_0 0x21 */ '1', /* sk_1 0x22 */ '4', /* sk_4 0x23 */ '7', /* sk_7 0x24 */ ',', /* sk_Comma 0x25 */ '\0', /* sk_Sin 0x26 */ '\0', /* sk_Apps 0x27 */ '\0', /* sk_GraphVar 0x28 */ '\0', /* 29 */ '\0', /* sk_Store 0x2A */ '\0', /* sk_Ln 0x2B */ '\0', /* sk_Log 0x2C */ '\0', /* sk_Square 0x2D */ '\0', /* sk_Recip 0x2E */ '\0', /* sk_Math 0x2F */ '\0', /* sk_Alpha 0x30 */ '\0', /* sk_Graph 0x31 */ '\0', /* sk_Trace 0x32 */ '\0', /* sk_Zoom 0x33 */ '\0', /* sk_Window 0x34 */ '\0', /* sk_Yequ 0x35 */ '\0', /* sk_2nd 0x36 */ '\0', /* sk_Mode 0x37 */ '\0' /* sk_Del 0x38 */ }, { /* Capital */ '\0', /* 0 */ '\0', /* sk_Down 0x01 */ '\0', /* sk_Left 0x02 */ '\0', /* sk_Right 0x03 */ '\0', /* sk_Up 0x04 */ '\0', '\0', '\0', '\0', /* 5, 6, 7, 8 */ '\0', /* sk_Enter 0x09 */ '\"', /* sk_Add 0x0A */ 'W', /* sk_Sub 0x0B */ 'R', /* sk_Mul 0x0C */ 'M', /* sk_Div 0x0D */ 'H', /* sk_Power 0x0E */ '\0', /* sk_Clear 0x0F */ '\0', /* 10 */ '?', /* sk_Chs 0x11 */ '\264', /* sk_3 0x12 */ 'V', /* sk_6 0x13 */ 'Q', /* sk_9 0x14 */ 'L', /* sk_RParen 0x15 */ 'G', /* sk_Tan 0x16 */ '\0', /* sk_Vars 0x17 */ '\0', /* 18 */ ':', /* sk_DecPnt 0x19 */ 'Z', /* sk_2 0x1A */ 'U', /* sk_5 0x1B */ 'P', /* sk_8 0x1C */ 'K', /* sk_LParen 0x1D */ 'F', /* sk_Cos 0x1E */ 'C', /* sk_Prgm 0x1F */ '\0', /* sk_Stat 0x20 */ ' ', /* sk_0 0x21 */ 'Y', /* sk_1 0x22 */ 'T', /* sk_4 0x23 */ 'O', /* sk_7 0x24 */ 'J', /* sk_Comma 0x25 */ 'E', /* sk_Sin 0x26 */ 'B', /* sk_Apps 0x27 */ '\0', /* sk_GraphVar 0x28 */ '\0', /* 29 */ 'X', /* sk_Store 0x2A */ 'S', /* sk_Ln 0x2B */ 'N', /* sk_Log 0x2C */ 'I', /* sk_Square 0x2D */ 'D', /* sk_Recip 0x2E */ 'A', /* sk_Math 0x2F */ '\0', /* sk_Alpha 0x30 */ '\0', /* sk_Graph 0x31 */ '\0', /* sk_Trace 0x32 */ '\0', /* sk_Zoom 0x33 */ '\0', /* sk_Window 0x34 */ '\0', /* sk_Yequ 0x35 */ '\0', /* sk_2nd 0x36 */ '\0', /* sk_Mode 0x37 */ '\0' /* sk_Del 0x38 */ }, { /* Lowercase */ '\0', /* 0 */ '\0', /* sk_Down 0x01 */ '\0', /* sk_Left 0x02 */ '\0', /* sk_Right 0x03 */ '\0', /* sk_Up 0x04 */ '\0', '\0', '\0', '\0', /* 5, 6, 7, 8 */ '\0', /* sk_Enter 0x09 */ '\'', /* sk_Add 0x0A */ 'w', /* sk_Sub 0x0B */ 'r', /* sk_Mul 0x0C */ 'm', /* sk_Div 0x0D */ 'h', /* sk_Power 0x0E */ '\0', /* sk_Clear 0x0F */ '\0', /* 10 */ '_', /* sk_Chs 0x11 */ '\264', /* sk_3 0x12 */ 'v', /* sk_6 0x13 */ 'q', /* sk_9 0x14 */ 'l', /* sk_RParen 0x15 */ 'g', /* sk_Tan 0x16 */ '\0', /* sk_Vars 0x17 */ '\0', /* 18 */ ';', /* sk_DecPnt 0x19 */ 'z', /* sk_2 0x1A */ 'u', /* sk_5 0x1B */ 'p', /* sk_8 0x1C */ 'k', /* sk_LParen 0x1D */ 'f', /* sk_Cos 0x1E */ 'c', /* sk_Prgm 0x1F */ '\0', /* sk_Stat 0x20 */ ' ', /* sk_0 0x21 */ 'y', /* sk_1 0x22 */ 't', /* sk_4 0x23 */ 'o', /* sk_7 0x24 */ 'j', /* sk_Comma 0x25 */ 'e', /* sk_Sin 0x26 */ 'b', /* sk_Apps 0x27 */ '\0', /* sk_GraphVar 0x28 */ '\0', /* 29 */ 'x', /* sk_Store 0x2A */ 's', /* sk_Ln 0x2B */ 'n', /* sk_Log 0x2C */ 'i', /* sk_Square 0x2D */ 'd', /* sk_Recip 0x2E */ 'a', /* sk_Math 0x2F */ '\0', /* sk_Alpha 0x30 */ '\0', /* sk_Graph 0x31 */ '\0', /* sk_Trace 0x32 */ '\0', /* sk_Zoom 0x33 */ '\0', /* sk_Window 0x34 */ '\0', /* sk_Yequ 0x35 */ '\0', /* sk_2nd 0x36 */ '\0', /* sk_Mode 0x37 */ '\0' /* sk_Del 0x38 */ } }; /** * Translates a keycode into a glyph. */ char editor_translate_key(char key, unsigned char shift) { if (shift <= shift_lower_alpha) return key_translation_table[shift][key]; return '\0'; } char cursors[] = {'\4', '\6', '\7'}; /* These are all 32-bit registers, but we don't need all 32 bits, and 32-bit * code sucks on the eZ80, so as a performance and code-size hack we're going * to treat these as single-byte registers as much as possible. * Look in for more information. */ #define timer_control_a (*(volatile unsigned char*)0xF20030) #define timer_control_b (*(volatile unsigned char*)0xF20031) #define timer_1_value (*(volatile unsigned char*)0xF20001) #define timer_1_value_b (*(volatile unsigned char*)0xF20002) #define timer_1_match_1 (*(unsigned char*)0xF2000A) #define timer_1_match_2 (*(unsigned char*)0xF2000E) /** * A string input routine. Gives the user access to their command history. * @note Despite its size, this routine still can't handle multiline text, nor * text wider than the text window; there is no scrolling logic. * @param x_loc Location of the editor * @param y_loc Location of the editor * @param box_width Width of the editor window; height is implied by font choice * @param text_max_length Maximum number of characters to accept * @param editor_font Font to use in the editor * @param default_text Places some text into the editor before letting the user * start typing. * @return A pointer to the text the user entered. You must free() this string * yourself. */ char* get_string(uint24_t x_loc, uint8_t y_loc, uint24_t box_width, uint8_t text_max_length, fontlib_font_t* editor_font, char* default_text) { editor_context_t* context; bool not_done = true; unsigned char temp; sk_key_t key; unsigned int apd_timer; bool dimmed = false; unsigned char shift = 2; context = editor_start(x_loc, y_loc, box_width, text_max_length, editor_font); context->cursor_glyph = cursors[shift]; if (default_text) { editor_set_str(context, default_text); editor_redraw(context); default_text = NULL; } /* Set timer 1 to count up */ timer_control_b = timer_control_b | 2; /* 0xF8 = Clear interrupt enable and disable timer 1 * 2 = Set timer 1 to use the RTC crystal (32768 Hz) */ timer_control_a = timer_control_a & 0xF8 | 2; /* Make sure match registers are disabled */ timer_1_match_1 = 0xFF; timer_1_match_2 = 0xFF; do { clear_on_key(); /* Reset timer 1 to 0. * Recall that timer 1 has already been turned off, so the non- * atomic writes won't cause a problem. */ timer_1_Counter = 0; apd_timer = get_rtc_seconds_plus(APD_DIM_TIME); /* Enable timer 1 */ timer_control_a = timer_control_a | 1; editor_show_cursor(context); do { /* Prevent battery killing */ if (get_rtc_seconds() == apd_timer) { if (!dimmed) { dimmed = true; lcd_dim(); apd_timer = get_rtc_seconds_plus(APD_QUIT_TIME); } else exit_apd(); } /* Check value of timer 1. We need only check one byte of the whole * 32-bit register. */ if (timer_1_value >= 64) { /* Turn timer off, zero it, and turn it back on */ timer_control_a = timer_control_a & 0xFA; timer_1_Counter = 0; timer_control_a = timer_control_a | 1; /* Flash cursor */ editor_toggle_cursor(context); } key = get_csc(); } while (!key); dimmed = false; lcd_bright(); /* Turn timer off */ timer_control_a = timer_control_a & 0xFA; editor_hide_cursor(context); switch (key) { case sk_Clear: editor_flush(context); break; case sk_Del: editor_left(context); editor_delete(context, 1); break; case sk_Left: editor_left(context); break; case sk_Right: editor_right(context); break; case sk_Enter: not_done = false; break; case sk_Alpha: shift = shift + 1; if (shift > 2) shift = 0; context->cursor_glyph = cursors[shift]; break; case sk_Up: temp = 1; if (get_history_item(temp) == NULL) break; do { fontlib_SetColors(context->bg_color, context->fg_color); fontlib_SetCursorPosition(context->base_x, context->base_y); fontlib_DrawString(get_history_item(temp)); fontlib_SetBackgroundColor(context->bg_color); fontlib_ClearEOL(); do key = os_GetCSC(); while (!key); switch (key) { case sk_Up: if (get_history_item(temp + 1) != NULL) temp++; break; case sk_Down: if (get_history_item(temp - 1) != NULL) temp--; break; case sk_Enter: editor_flush(context); editor_set_str(context, get_history_item(temp)); not_done = false; break; case sk_Clear: case sk_Del: case sk_Mode: not_done = false; break; } } while (not_done); editor_redraw(context); not_done = true; break; default: key = editor_translate_key(key, shift); if (key != '\0') { editor_insert(context, key); editor_right(context); } } } while (not_done); return editor_get_string_close(context); }