FlipWorld: Tweaks for Momentum

flip_world/application.fam

@@ -5,7 +5,7 @@ App(
     entry_point="flip_world_main",
     stack_size=4 * 1024,
     fap_icon="app.png",
-    fap_category="GPIO",
+    fap_category="GPIO/FlipperHTTP",
     fap_description="The first open-world multiplayer game, best played with the VGM.",
     fap_icon_assets="assets",
     fap_file_assets="file_assets",

flip_world/callback/callback.c

@@ -518,7 +518,7 @@ static void free_text_input_view(void *context)
     if (app->text_input)
     {
         view_dispatcher_remove_view(app->view_dispatcher, FlipWorldViewTextInput);
-        uart_text_input_free(app->text_input);
+        text_input_free(app->text_input);
         app->text_input = NULL;
     }
     if (app->text_input_buffer)

flip_world/easy_flipper/easy_flipper.c

@@ -340,15 +340,15 @@ bool easy_flipper_set_text_input(
 }
 
 /**
- * @brief Initialize a UART_TextInput object
- * @param uart_text_input The UART_TextInput object to initialize
+ * @brief Initialize a TextInput object with extra symbols
+ * @param uart_text_input The TextInput object to initialize
  * @param view_id The ID/Index of the view
  * @param previous_callback The previous callback function (can be set to NULL)
  * @param view_dispatcher The ViewDispatcher object
  * @return true if successful, false otherwise
  */
 bool easy_flipper_set_uart_text_input(
-    UART_TextInput **uart_text_input,
+    TextInput **uart_text_input,
     int32_t view_id,
     char *header_text,
     char *uart_text_input_temp_buffer,
@@ -363,7 +363,7 @@ bool easy_flipper_set_uart_text_input(
         FURI_LOG_E(EASY_TAG, "Invalid arguments provided to set_uart_text_input");
         return false;
     }
-    *uart_text_input = uart_text_input_alloc();
+    *uart_text_input = text_input_alloc();
     if (!*uart_text_input)
     {
         FURI_LOG_E(EASY_TAG, "Failed to allocate UART_TextInput");
@@ -371,17 +371,18 @@ bool easy_flipper_set_uart_text_input(
     }
     if (previous_callback)
     {
-        view_set_previous_callback(uart_text_input_get_view(*uart_text_input), previous_callback);
+        view_set_previous_callback(text_input_get_view(*uart_text_input), previous_callback);
     }
     if (header_text)
     {
-        uart_text_input_set_header_text(*uart_text_input, header_text);
+        text_input_set_header_text(*uart_text_input, header_text);
     }
     if (uart_text_input_temp_buffer && uart_text_input_buffer_size && result_callback)
     {
-        uart_text_input_set_result_callback(*uart_text_input, result_callback, context, uart_text_input_temp_buffer, uart_text_input_buffer_size, false);
+        text_input_set_result_callback(*uart_text_input, result_callback, context, uart_text_input_temp_buffer, uart_text_input_buffer_size, false);
     }
-    view_dispatcher_add_view(*view_dispatcher, view_id, uart_text_input_get_view(*uart_text_input));
+    text_input_show_illegal_symbols(*uart_text_input, true);
+    view_dispatcher_add_view(*view_dispatcher, view_id, text_input_get_view(*uart_text_input));
     return true;
 }
 

flip_world/easy_flipper/easy_flipper.h

@@ -20,7 +20,6 @@
 #include <dialogs/dialogs.h>
 #include <gui/modules/popup.h>
 #include <gui/modules/loading.h>
-#include <text_input/uart_text_input.h>
 #include <stdio.h>
 #include <string.h>
 #include <jsmn/jsmn_furi.h>
@@ -161,15 +160,15 @@ bool easy_flipper_set_text_input(
     void *context);
 
 /**
- * @brief Initialize a UART_TextInput object
- * @param uart_text_input The UART_TextInput object to initialize
+ * @brief Initialize a TextInput object with extra symbols
+ * @param uart_text_input The TextInput object to initialize
  * @param view_id The ID/Index of the view
  * @param previous_callback The previous callback function (can be set to NULL)
  * @param view_dispatcher The ViewDispatcher object
  * @return true if successful, false otherwise
  */
 bool easy_flipper_set_uart_text_input(
-    UART_TextInput **uart_text_input,
+    TextInput **uart_text_input,
     int32_t view_id,
     char *header_text,
     char *uart_text_input_temp_buffer,

flip_world/flip_world.h

@@ -66,7 +66,7 @@ typedef struct
     VariableItem *variable_item_user_username; // The variable item for the User username
     VariableItem *variable_item_user_password; // The variable item for the User password
 
-    UART_TextInput *text_input;      // The text input
+    TextInput *text_input;      // The text input
     char *text_input_buffer;         // Buffer for the text input
     char *text_input_temp_buffer;    // Temporary buffer for the text input
     uint32_t text_input_buffer_size; // Size of the text input buffer

flip_world/flipper_http/flipper_http.h

@@ -13,12 +13,13 @@
 #include <furi_hal_gpio.h>
 #include <furi_hal_serial.h>
 #include <storage/storage.h>
+#include <momentum/settings.h>
 
 // STORAGE_EXT_PATH_PREFIX is defined in the Furi SDK as /ext
 
 #define HTTP_TAG "FlipWorld"              // change this to your app name
 #define http_tag "flip_world"             // change this to your app id
-#define UART_CH (FuriHalSerialIdUsart)    // UART channel
+#define UART_CH (momentum_settings.uart_esp_channel)    // UART channel
 #define TIMEOUT_DURATION_TICKS (5 * 1000) // 5 seconds
 #define BAUDRATE (115200)                 // UART baudrate
 #define RX_BUF_SIZE 2048                  // UART RX buffer size

flip_world/text_input/uart_text_input.c

@@ -1,784 +0,0 @@
-// from https://github.com/xMasterX/all-the-plugins/blob/dev/base_pack/uart_terminal/uart_text_input.c
-// all credits to xMasterX for the code
-#include "uart_text_input.h"
-#include <gui/elements.h>
-#include "flip_world_icons.h"
-#include <furi.h>
-
-struct UART_TextInput
-{
-    View *view;
-    FuriTimer *timer;
-};
-
-typedef struct
-{
-    const char text;
-    const uint8_t x;
-    const uint8_t y;
-} UART_TextInputKey;
-
-typedef struct
-{
-    const char *header;
-    char *text_buffer;
-    size_t text_buffer_size;
-    bool clear_default_text;
-
-    UART_TextInputCallback callback;
-    void *callback_context;
-
-    uint8_t selected_row;
-    uint8_t selected_column;
-
-    UART_TextInputValidatorCallback validator_callback;
-    void *validator_callback_context;
-    FuriString *validator_text;
-    bool valadator_message_visible;
-} UART_TextInputModel;
-
-static const uint8_t keyboard_origin_x = 1;
-static const uint8_t keyboard_origin_y = 29;
-static const uint8_t keyboard_row_count = 4;
-
-#define mode_AT "Send AT command to UART"
-
-#define ENTER_KEY '\r'
-#define BACKSPACE_KEY '\b'
-
-static const UART_TextInputKey keyboard_keys_row_1[] = {
-    {'{', 1, 0},
-    {'(', 9, 0},
-    {'[', 17, 0},
-    {'|', 25, 0},
-    {'@', 33, 0},
-    {'&', 41, 0},
-    {'#', 49, 0},
-    {';', 57, 0},
-    {'^', 65, 0},
-    {'*', 73, 0},
-    {'`', 81, 0},
-    {'"', 89, 0},
-    {'~', 97, 0},
-    {'\'', 105, 0},
-    {'.', 113, 0},
-    {'/', 120, 0},
-};
-
-static const UART_TextInputKey keyboard_keys_row_2[] = {
-    {'q', 1, 10},
-    {'w', 9, 10},
-    {'e', 17, 10},
-    {'r', 25, 10},
-    {'t', 33, 10},
-    {'y', 41, 10},
-    {'u', 49, 10},
-    {'i', 57, 10},
-    {'o', 65, 10},
-    {'p', 73, 10},
-    {'0', 81, 10},
-    {'1', 89, 10},
-    {'2', 97, 10},
-    {'3', 105, 10},
-    {'=', 113, 10},
-    {'-', 120, 10},
-};
-
-static const UART_TextInputKey keyboard_keys_row_3[] = {
-    {'a', 1, 21},
-    {'s', 9, 21},
-    {'d', 18, 21},
-    {'f', 25, 21},
-    {'g', 33, 21},
-    {'h', 41, 21},
-    {'j', 49, 21},
-    {'k', 57, 21},
-    {'l', 65, 21},
-    {BACKSPACE_KEY, 72, 13},
-    {'4', 89, 21},
-    {'5', 97, 21},
-    {'6', 105, 21},
-    {'$', 113, 21},
-    {'%', 120, 21},
-
-};
-
-static const UART_TextInputKey keyboard_keys_row_4[] = {
-    {'z', 1, 33},
-    {'x', 9, 33},
-    {'c', 18, 33},
-    {'v', 25, 33},
-    {'b', 33, 33},
-    {'n', 41, 33},
-    {'m', 49, 33},
-    {'_', 57, 33},
-    {ENTER_KEY, 64, 24},
-    {'7', 89, 33},
-    {'8', 97, 33},
-    {'9', 105, 33},
-    {'!', 113, 33},
-    {'+', 120, 33},
-};
-
-static uint8_t get_row_size(uint8_t row_index)
-{
-    uint8_t row_size = 0;
-
-    switch (row_index + 1)
-    {
-    case 1:
-        row_size = sizeof(keyboard_keys_row_1) / sizeof(UART_TextInputKey);
-        break;
-    case 2:
-        row_size = sizeof(keyboard_keys_row_2) / sizeof(UART_TextInputKey);
-        break;
-    case 3:
-        row_size = sizeof(keyboard_keys_row_3) / sizeof(UART_TextInputKey);
-        break;
-    case 4:
-        row_size = sizeof(keyboard_keys_row_4) / sizeof(UART_TextInputKey);
-        break;
-    }
-
-    return row_size;
-}
-
-static const UART_TextInputKey *get_row(uint8_t row_index)
-{
-    const UART_TextInputKey *row = NULL;
-
-    switch (row_index + 1)
-    {
-    case 1:
-        row = keyboard_keys_row_1;
-        break;
-    case 2:
-        row = keyboard_keys_row_2;
-        break;
-    case 3:
-        row = keyboard_keys_row_3;
-        break;
-    case 4:
-        row = keyboard_keys_row_4;
-        break;
-    }
-
-    return row;
-}
-
-static char get_selected_char(UART_TextInputModel *model)
-{
-    return get_row(model->selected_row)[model->selected_column].text;
-}
-
-static bool char_is_lowercase(char letter)
-{
-    return (letter >= 0x61 && letter <= 0x7A);
-}
-
-static bool char_is_uppercase(char letter)
-{
-    return (letter >= 0x41 && letter <= 0x5A);
-}
-
-static char char_to_lowercase(const char letter)
-{
-    switch (letter)
-    {
-    case ' ':
-        return 0x5f;
-        break;
-    case ')':
-        return 0x28;
-        break;
-    case '}':
-        return 0x7b;
-        break;
-    case ']':
-        return 0x5b;
-        break;
-    case '\\':
-        return 0x2f;
-        break;
-    case ':':
-        return 0x3b;
-        break;
-    case ',':
-        return 0x2e;
-        break;
-    case '?':
-        return 0x21;
-        break;
-    case '>':
-        return 0x3c;
-        break;
-    }
-    if (char_is_uppercase(letter))
-    {
-        return (letter + 0x20);
-    }
-    else
-    {
-        return letter;
-    }
-}
-
-static char char_to_uppercase(const char letter)
-{
-    switch (letter)
-    {
-    case '_':
-        return 0x20;
-        break;
-    case '(':
-        return 0x29;
-        break;
-    case '{':
-        return 0x7d;
-        break;
-    case '[':
-        return 0x5d;
-        break;
-    case '/':
-        return 0x5c;
-        break;
-    case ';':
-        return 0x3a;
-        break;
-    case '.':
-        return 0x2c;
-        break;
-    case '!':
-        return 0x3f;
-        break;
-    case '<':
-        return 0x3e;
-        break;
-    }
-    if (char_is_lowercase(letter))
-    {
-        return (letter - 0x20);
-    }
-    else
-    {
-        return letter;
-    }
-}
-
-static void uart_text_input_backspace_cb(UART_TextInputModel *model)
-{
-    uint8_t text_length = model->clear_default_text ? 1 : strlen(model->text_buffer);
-    if (text_length > 0)
-    {
-        model->text_buffer[text_length - 1] = 0;
-    }
-}
-
-static void uart_text_input_view_draw_callback(Canvas *canvas, void *_model)
-{
-    UART_TextInputModel *model = _model;
-    // uint8_t text_length = model->text_buffer ? strlen(model->text_buffer) : 0;
-    uint8_t needed_string_width = canvas_width(canvas) - 8;
-    uint8_t start_pos = 4;
-
-    const char *text = model->text_buffer;
-
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-
-    canvas_draw_str(canvas, 2, 7, model->header);
-    elements_slightly_rounded_frame(canvas, 1, 8, 126, 12);
-
-    if (canvas_string_width(canvas, text) > needed_string_width)
-    {
-        canvas_draw_str(canvas, start_pos, 17, "...");
-        start_pos += 6;
-        needed_string_width -= 8;
-    }
-
-    while (text != 0 && canvas_string_width(canvas, text) > needed_string_width)
-    {
-        text++;
-    }
-
-    if (model->clear_default_text)
-    {
-        elements_slightly_rounded_box(
-            canvas, start_pos - 1, 14, canvas_string_width(canvas, text) + 2, 10);
-        canvas_set_color(canvas, ColorWhite);
-    }
-    else
-    {
-        canvas_draw_str(canvas, start_pos + canvas_string_width(canvas, text) + 1, 18, "|");
-        canvas_draw_str(canvas, start_pos + canvas_string_width(canvas, text) + 2, 18, "|");
-    }
-    canvas_draw_str(canvas, start_pos, 17, text);
-
-    canvas_set_font(canvas, FontKeyboard);
-
-    for (uint8_t row = 0; row <= keyboard_row_count; row++)
-    {
-        const uint8_t column_count = get_row_size(row);
-        const UART_TextInputKey *keys = get_row(row);
-
-        for (size_t column = 0; column < column_count; column++)
-        {
-            if (keys[column].text == ENTER_KEY)
-            {
-                canvas_set_color(canvas, ColorBlack);
-                if (model->selected_row == row && model->selected_column == column)
-                {
-                    canvas_draw_icon(
-                        canvas,
-                        keyboard_origin_x + keys[column].x,
-                        keyboard_origin_y + keys[column].y,
-                        &I_KeySaveSelected_24x11);
-                }
-                else
-                {
-                    canvas_draw_icon(
-                        canvas,
-                        keyboard_origin_x + keys[column].x,
-                        keyboard_origin_y + keys[column].y,
-                        &I_KeySave_24x11);
-                }
-            }
-            else if (keys[column].text == BACKSPACE_KEY)
-            {
-                canvas_set_color(canvas, ColorBlack);
-                if (model->selected_row == row && model->selected_column == column)
-                {
-                    canvas_draw_icon(
-                        canvas,
-                        keyboard_origin_x + keys[column].x,
-                        keyboard_origin_y + keys[column].y,
-                        &I_KeyBackspaceSelected_16x9);
-                }
-                else
-                {
-                    canvas_draw_icon(
-                        canvas,
-                        keyboard_origin_x + keys[column].x,
-                        keyboard_origin_y + keys[column].y,
-                        &I_KeyBackspace_16x9);
-                }
-            }
-            else
-            {
-                if (model->selected_row == row && model->selected_column == column)
-                {
-                    canvas_set_color(canvas, ColorBlack);
-                    canvas_draw_box(
-                        canvas,
-                        keyboard_origin_x + keys[column].x - 1,
-                        keyboard_origin_y + keys[column].y - 8,
-                        7,
-                        10);
-                    canvas_set_color(canvas, ColorWhite);
-                }
-                else
-                {
-                    canvas_set_color(canvas, ColorBlack);
-                }
-                if (0 == strcmp(model->header, mode_AT))
-                {
-                    canvas_draw_glyph(
-                        canvas,
-                        keyboard_origin_x + keys[column].x,
-                        keyboard_origin_y + keys[column].y,
-                        char_to_uppercase(keys[column].text));
-                }
-                else
-                {
-                    canvas_draw_glyph(
-                        canvas,
-                        keyboard_origin_x + keys[column].x,
-                        keyboard_origin_y + keys[column].y,
-                        keys[column].text);
-                }
-            }
-        }
-    }
-    if (model->valadator_message_visible)
-    {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_set_color(canvas, ColorWhite);
-        canvas_draw_box(canvas, 8, 10, 110, 48);
-        canvas_set_color(canvas, ColorBlack);
-        canvas_draw_icon(canvas, 10, 14, &I_WarningDolphin_45x42);
-        canvas_draw_rframe(canvas, 8, 8, 112, 50, 3);
-        canvas_draw_rframe(canvas, 9, 9, 110, 48, 2);
-        elements_multiline_text(canvas, 62, 20, furi_string_get_cstr(model->validator_text));
-        canvas_set_font(canvas, FontKeyboard);
-    }
-}
-
-static void
-uart_text_input_handle_up(UART_TextInput *uart_text_input, UART_TextInputModel *model)
-{
-    UNUSED(uart_text_input);
-    if (model->selected_row > 0)
-    {
-        model->selected_row--;
-        if (model->selected_column > get_row_size(model->selected_row) - 6)
-        {
-            model->selected_column = model->selected_column + 1;
-        }
-    }
-}
-
-static void
-uart_text_input_handle_down(UART_TextInput *uart_text_input, UART_TextInputModel *model)
-{
-    UNUSED(uart_text_input);
-    if (model->selected_row < keyboard_row_count - 1)
-    {
-        model->selected_row++;
-        if (model->selected_column > get_row_size(model->selected_row) - 4)
-        {
-            model->selected_column = model->selected_column - 1;
-        }
-    }
-}
-
-static void
-uart_text_input_handle_left(UART_TextInput *uart_text_input, UART_TextInputModel *model)
-{
-    UNUSED(uart_text_input);
-    if (model->selected_column > 0)
-    {
-        model->selected_column--;
-    }
-    else
-    {
-        model->selected_column = get_row_size(model->selected_row) - 1;
-    }
-}
-
-static void
-uart_text_input_handle_right(UART_TextInput *uart_text_input, UART_TextInputModel *model)
-{
-    UNUSED(uart_text_input);
-    if (model->selected_column < get_row_size(model->selected_row) - 1)
-    {
-        model->selected_column++;
-    }
-    else
-    {
-        model->selected_column = 0;
-    }
-}
-
-static void uart_text_input_handle_ok(
-    UART_TextInput *uart_text_input,
-    UART_TextInputModel *model,
-    bool shift)
-{
-    char selected = get_selected_char(model);
-    uint8_t text_length = strlen(model->text_buffer);
-
-    if (0 == strcmp(model->header, mode_AT))
-    {
-        selected = char_to_uppercase(selected);
-    }
-
-    if (shift)
-    {
-        if (0 == strcmp(model->header, mode_AT))
-        {
-            selected = char_to_lowercase(selected);
-        }
-        else
-        {
-            selected = char_to_uppercase(selected);
-        }
-    }
-
-    if (selected == ENTER_KEY)
-    {
-        if (model->validator_callback &&
-            (!model->validator_callback(
-                model->text_buffer, model->validator_text, model->validator_callback_context)))
-        {
-            model->valadator_message_visible = true;
-            furi_timer_start(uart_text_input->timer, furi_kernel_get_tick_frequency() * 4);
-        }
-        else if (model->callback != 0 && text_length > 0)
-        {
-            model->callback(model->callback_context);
-        }
-    }
-    else if (selected == BACKSPACE_KEY)
-    {
-        uart_text_input_backspace_cb(model);
-    }
-    else
-    {
-        if (model->clear_default_text)
-        {
-            text_length = 0;
-        }
-        if (text_length < (model->text_buffer_size - 1))
-        {
-            model->text_buffer[text_length] = selected;
-            model->text_buffer[text_length + 1] = 0;
-        }
-    }
-    model->clear_default_text = false;
-}
-
-static bool uart_text_input_view_input_callback(InputEvent *event, void *context)
-{
-    UART_TextInput *uart_text_input = context;
-    furi_assert(uart_text_input);
-
-    bool consumed = false;
-
-    // Acquire model
-    UART_TextInputModel *model = view_get_model(uart_text_input->view);
-
-    if ((!(event->type == InputTypePress) && !(event->type == InputTypeRelease)) &&
-        model->valadator_message_visible)
-    {
-        model->valadator_message_visible = false;
-        consumed = true;
-    }
-    else if (event->type == InputTypeShort)
-    {
-        consumed = true;
-        switch (event->key)
-        {
-        case InputKeyUp:
-            uart_text_input_handle_up(uart_text_input, model);
-            break;
-        case InputKeyDown:
-            uart_text_input_handle_down(uart_text_input, model);
-            break;
-        case InputKeyLeft:
-            uart_text_input_handle_left(uart_text_input, model);
-            break;
-        case InputKeyRight:
-            uart_text_input_handle_right(uart_text_input, model);
-            break;
-        case InputKeyOk:
-            uart_text_input_handle_ok(uart_text_input, model, false);
-            break;
-        default:
-            consumed = false;
-            break;
-        }
-    }
-    else if (event->type == InputTypeLong)
-    {
-        consumed = true;
-        switch (event->key)
-        {
-        case InputKeyUp:
-            uart_text_input_handle_up(uart_text_input, model);
-            break;
-        case InputKeyDown:
-            uart_text_input_handle_down(uart_text_input, model);
-            break;
-        case InputKeyLeft:
-            uart_text_input_handle_left(uart_text_input, model);
-            break;
-        case InputKeyRight:
-            uart_text_input_handle_right(uart_text_input, model);
-            break;
-        case InputKeyOk:
-            uart_text_input_handle_ok(uart_text_input, model, true);
-            break;
-        case InputKeyBack:
-            uart_text_input_backspace_cb(model);
-            break;
-        default:
-            consumed = false;
-            break;
-        }
-    }
-    else if (event->type == InputTypeRepeat)
-    {
-        consumed = true;
-        switch (event->key)
-        {
-        case InputKeyUp:
-            uart_text_input_handle_up(uart_text_input, model);
-            break;
-        case InputKeyDown:
-            uart_text_input_handle_down(uart_text_input, model);
-            break;
-        case InputKeyLeft:
-            uart_text_input_handle_left(uart_text_input, model);
-            break;
-        case InputKeyRight:
-            uart_text_input_handle_right(uart_text_input, model);
-            break;
-        case InputKeyBack:
-            uart_text_input_backspace_cb(model);
-            break;
-        default:
-            consumed = false;
-            break;
-        }
-    }
-
-    // Commit model
-    view_commit_model(uart_text_input->view, consumed);
-
-    return consumed;
-}
-
-void uart_text_input_timer_callback(void *context)
-{
-    furi_assert(context);
-    UART_TextInput *uart_text_input = context;
-
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        { model->valadator_message_visible = false; },
-        true);
-}
-
-UART_TextInput *uart_text_input_alloc()
-{
-    UART_TextInput *uart_text_input = malloc(sizeof(UART_TextInput));
-    uart_text_input->view = view_alloc();
-    view_set_context(uart_text_input->view, uart_text_input);
-    view_allocate_model(uart_text_input->view, ViewModelTypeLocking, sizeof(UART_TextInputModel));
-    view_set_draw_callback(uart_text_input->view, uart_text_input_view_draw_callback);
-    view_set_input_callback(uart_text_input->view, uart_text_input_view_input_callback);
-
-    uart_text_input->timer =
-        furi_timer_alloc(uart_text_input_timer_callback, FuriTimerTypeOnce, uart_text_input);
-
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        { model->validator_text = furi_string_alloc(); },
-        false);
-
-    uart_text_input_reset(uart_text_input);
-
-    return uart_text_input;
-}
-
-void uart_text_input_free(UART_TextInput *uart_text_input)
-{
-    furi_assert(uart_text_input);
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        { furi_string_free(model->validator_text); },
-        false);
-
-    // Send stop command
-    furi_timer_stop(uart_text_input->timer);
-    // Release allocated memory
-    furi_timer_free(uart_text_input->timer);
-
-    view_free(uart_text_input->view);
-
-    free(uart_text_input);
-}
-
-void uart_text_input_reset(UART_TextInput *uart_text_input)
-{
-    furi_assert(uart_text_input);
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        {
-            model->text_buffer_size = 0;
-            model->header = "";
-            model->selected_row = 0;
-            model->selected_column = 0;
-            model->clear_default_text = false;
-            model->text_buffer = NULL;
-            model->text_buffer_size = 0;
-            model->callback = NULL;
-            model->callback_context = NULL;
-            model->validator_callback = NULL;
-            model->validator_callback_context = NULL;
-            furi_string_reset(model->validator_text);
-            model->valadator_message_visible = false;
-        },
-        true);
-}
-
-View *uart_text_input_get_view(UART_TextInput *uart_text_input)
-{
-    furi_assert(uart_text_input);
-    return uart_text_input->view;
-}
-
-void uart_text_input_set_result_callback(
-    UART_TextInput *uart_text_input,
-    UART_TextInputCallback callback,
-    void *callback_context,
-    char *text_buffer,
-    size_t text_buffer_size,
-    bool clear_default_text)
-{
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        {
-            model->callback = callback;
-            model->callback_context = callback_context;
-            model->text_buffer = text_buffer;
-            model->text_buffer_size = text_buffer_size;
-            model->clear_default_text = clear_default_text;
-            if (text_buffer && text_buffer[0] != '\0')
-            {
-                // Set focus on Save
-                model->selected_row = 2;
-                model->selected_column = 8;
-            }
-        },
-        true);
-}
-
-void uart_text_input_set_validator(
-    UART_TextInput *uart_text_input,
-    UART_TextInputValidatorCallback callback,
-    void *callback_context)
-{
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        {
-            model->validator_callback = callback;
-            model->validator_callback_context = callback_context;
-        },
-        true);
-}
-
-UART_TextInputValidatorCallback
-uart_text_input_get_validator_callback(UART_TextInput *uart_text_input)
-{
-    UART_TextInputValidatorCallback validator_callback = NULL;
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        { validator_callback = model->validator_callback; },
-        false);
-    return validator_callback;
-}
-
-void *uart_text_input_get_validator_callback_context(UART_TextInput *uart_text_input)
-{
-    void *validator_callback_context = NULL;
-    with_view_model(
-        uart_text_input->view,
-        UART_TextInputModel * model,
-        { validator_callback_context = model->validator_callback_context; },
-        false);
-    return validator_callback_context;
-}
-
-void uart_text_input_set_header_text(UART_TextInput *uart_text_input, const char *text)
-{
-    with_view_model(
-        uart_text_input->view, UART_TextInputModel * model, { model->header = text; }, true);
-}

flip_world/text_input/uart_text_input.h

@@ -1,83 +0,0 @@
-#pragma once
-// from https://github.com/xMasterX/all-the-plugins/blob/dev/base_pack/uart_terminal/uart_text_input.c
-// all credits to xMasterX for the code
-#include <gui/view.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    /** Text input anonymous structure */
-    typedef struct UART_TextInput UART_TextInput;
-    typedef void (*UART_TextInputCallback)(void *context);
-    typedef bool (*UART_TextInputValidatorCallback)(const char *text, FuriString *error, void *context);
-
-    /** Allocate and initialize text input
-     *
-     * This text input is used to enter string
-     *
-     * @return     UART_TextInput instance
-     */
-    UART_TextInput *uart_text_input_alloc();
-
-    /** Deinitialize and free text input
-     *
-     * @param      uart_text_input  UART_TextInput instance
-     */
-    void uart_text_input_free(UART_TextInput *uart_text_input);
-
-    /** Clean text input view Note: this function does not free memory
-     *
-     * @param      uart_text_input  Text input instance
-     */
-    void uart_text_input_reset(UART_TextInput *uart_text_input);
-
-    /** Get text input view
-     *
-     * @param      uart_text_input  UART_TextInput instance
-     *
-     * @return     View instance that can be used for embedding
-     */
-    View *uart_text_input_get_view(UART_TextInput *uart_text_input);
-
-    /** Set text input result callback
-     *
-     * @param      uart_text_input          UART_TextInput instance
-     * @param      callback            callback fn
-     * @param      callback_context    callback context
-     * @param      text_buffer         pointer to YOUR text buffer, that we going
-     *                                 to modify
-     * @param      text_buffer_size    YOUR text buffer size in bytes. Max string
-     *                                 length will be text_buffer_size-1.
-     * @param      clear_default_text  clear text from text_buffer on first OK
-     *                                 event
-     */
-    void uart_text_input_set_result_callback(
-        UART_TextInput *uart_text_input,
-        UART_TextInputCallback callback,
-        void *callback_context,
-        char *text_buffer,
-        size_t text_buffer_size,
-        bool clear_default_text);
-
-    void uart_text_input_set_validator(
-        UART_TextInput *uart_text_input,
-        UART_TextInputValidatorCallback callback,
-        void *callback_context);
-
-    UART_TextInputValidatorCallback
-    uart_text_input_get_validator_callback(UART_TextInput *uart_text_input);
-
-    void *uart_text_input_get_validator_callback_context(UART_TextInput *uart_text_input);
-
-    /** Set text input header text
-     *
-     * @param      uart_text_input  UART_TextInput instance
-     * @param      text        text to be shown
-     */
-    void uart_text_input_set_header_text(UART_TextInput *uart_text_input, const char *text);
-
-#ifdef __cplusplus
-}
-#endif