Started on UI for Station Id

application.fam

@@ -8,6 +8,7 @@ App(
     fap_icon_assets="icons",
     fap_category="Sub-Ghz",
     fap_version="1.0",
+    fap_libs=["assets"],
     fap_author="leedave",
     fap_weburl="https://github.com/leedave/flipper-zero-meal-pager",
     fap_description="This app triggers restaurant pagers in a brute force manner, useful to test if devices are still functional.",

helpers/gui/int_input.c

@@ -0,0 +1,863 @@
+#include "int_input.h"
+
+#include <gui/elements.h>
+#include <furi.h>
+#include <assets_icons.h>
+
+/** IntInput type */
+struct IntInput {
+    View* view;
+};
+
+typedef struct {
+    const uint8_t value;
+    const uint8_t x;
+    const uint8_t y;
+} IntInputKey;
+
+typedef struct {
+    const char* header;
+    uint8_t* bytes;
+    uint8_t bytes_count;
+
+    IntInputCallback input_callback;
+    IntChangedCallback changed_callback;
+    void* callback_context;
+
+    bool selected_high_nibble;
+    uint8_t selected_byte;
+    int8_t selected_row; // row -2 - mini_editor, -1 - input, row 0 & 1 - keyboard
+    uint8_t selected_column;
+    uint8_t first_visible_byte;
+} IntInputModel;
+
+static const uint8_t keyboard_origin_x = 7;
+static const uint8_t keyboard_origin_y = 31;
+static const uint8_t keyboard_row_count = 2;
+static const uint8_t enter_symbol = '\r';
+static const uint8_t backspace_symbol = '\b';
+static const uint8_t max_drawable_bytes = 8;
+
+static const IntInputKey keyboard_keys_row_1[] = {
+    {'0', 0, 12},
+    {'1', 11, 12},
+    {'2', 22, 12},
+    {'3', 33, 12},
+    {'4', 44, 12},
+    {backspace_symbol, 103, 4},
+};
+
+static const IntInputKey keyboard_keys_row_2[] = {
+    {'5', 0, 26},
+    {'6', 11, 26},
+    {'7', 22, 26},
+    {'8', 33, 26},
+    {'9', 44, 26},
+    {enter_symbol, 95, 17},
+};
+
+/** Get row size
+ *
+ * @param      row_index  Index of row
+ *
+ * @return     uint8_t Row size
+ */
+static uint8_t int_input_get_row_size(uint8_t row_index) {
+    uint8_t row_size = 0;
+
+    switch(row_index + 1) {
+    case 1:
+        row_size = COUNT_OF(keyboard_keys_row_1);
+        break;
+    case 2:
+        row_size = COUNT_OF(keyboard_keys_row_2);
+        break;
+    default:
+        furi_crash();
+    }
+
+    return row_size;
+}
+
+/** Get row pointer
+ *
+ * @param      row_index  Index of row
+ *
+ * @return     const IntInputKey* Row pointer
+ */
+static const IntInputKey* int_input_get_row(uint8_t row_index) {
+    const IntInputKey* row = NULL;
+
+    switch(row_index + 1) {
+    case 1:
+        row = keyboard_keys_row_1;
+        break;
+    case 2:
+        row = keyboard_keys_row_2;
+        break;
+    default:
+        furi_crash();
+    }
+
+    return row;
+}
+
+/** Get text from nibble
+ *
+ * @param      byte         byte value
+ * @param      high_nibble  Get from high nibble, otherwise low nibble
+ *
+ * @return     char nibble text
+ */
+static char int_input_get_nibble_text(uint8_t byte, bool high_nibble) {
+    if(high_nibble) {
+        byte = byte >> 4;
+    }
+    byte = byte & 0x0F;
+
+    switch(byte & 0x0F) {
+    case 0x0:
+    case 0x1:
+    case 0x2:
+    case 0x3:
+    case 0x4:
+    case 0x5:
+    case 0x6:
+    case 0x7:
+    case 0x8:
+    case 0x9:
+        byte = byte + '0';
+        break;
+    case 0xA:
+    case 0xB:
+    case 0xC:
+    case 0xD:
+    case 0xE:
+    case 0xF:
+        byte = byte - 0xA + 'A';
+        break;
+    default:
+        byte = '!';
+        break;
+    }
+
+    return byte;
+}
+
+const char num_to_char[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+
+/** Draw input box (common view)
+ *
+ * @param      canvas  The canvas
+ * @param      model   The model
+ */
+static void int_input_draw_input(Canvas* canvas, IntInputModel* model) {
+    const uint8_t text_x = 8;
+    const uint8_t text_y = 25;
+    const uint8_t text_y2 = 40;
+    const bool draw_index_line =
+        (model->selected_row == -2) &&
+        (model->first_visible_byte + MIN(model->bytes_count, max_drawable_bytes + 1) <= 100);
+
+    elements_slightly_rounded_frame(canvas, 6, 14, 116, 15);
+
+    canvas_draw_icon(canvas, 2, 19, &I_ButtonLeftSmall_3x5);
+    canvas_draw_icon(canvas, 123, 19, &I_ButtonRightSmall_3x5);
+
+    for(uint8_t i = model->first_visible_byte;
+        i < model->first_visible_byte + MIN(model->bytes_count, max_drawable_bytes);
+        i++) {
+        uint8_t byte_position = i - model->first_visible_byte;
+
+        if(i == model->selected_byte) {
+            canvas_draw_frame(canvas, text_x + byte_position * 14, text_y - 9, 15, 11);
+            if(model->selected_row == -2) {
+                canvas_draw_icon(
+                    canvas, text_x + 6 + byte_position * 14, text_y - 14, &I_arrow_nano_up);
+                canvas_draw_icon(
+                    canvas, text_x + 6 + byte_position * 14, text_y + 5, &I_arrow_nano_down);
+            }
+
+            if(model->selected_high_nibble) {
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 8 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], false));
+                canvas_draw_box(canvas, text_x + 1 + byte_position * 14, text_y - 8, 7, 9);
+                canvas_invert_color(canvas);
+                canvas_draw_line(
+                    canvas,
+                    text_x + 14 + byte_position * 14,
+                    text_y - 6,
+                    text_x + 14 + byte_position * 14,
+                    text_y - 2);
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 2 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], true));
+                canvas_invert_color(canvas);
+            } else {
+                canvas_draw_box(canvas, text_x + 7 + byte_position * 14, text_y - 8, 7, 9);
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 2 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], true));
+                canvas_invert_color(canvas);
+                canvas_draw_line(
+                    canvas,
+                    text_x + byte_position * 14,
+                    text_y - 6,
+                    text_x + byte_position * 14,
+                    text_y - 2);
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 8 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], false));
+                canvas_invert_color(canvas);
+            }
+        } else {
+            if(model->first_visible_byte > 0 && i == model->first_visible_byte) {
+                canvas_draw_icon(
+                    canvas,
+                    text_x + 2 + byte_position * 14,
+                    text_y - 7,
+                    &I_More_data_placeholder_5x7);
+            } else {
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 2 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], true));
+            }
+            if(model->bytes_count - model->first_visible_byte > max_drawable_bytes &&
+               i == model->first_visible_byte + MIN(model->bytes_count, max_drawable_bytes) - 1) {
+                canvas_draw_icon(
+                    canvas,
+                    text_x + 8 + byte_position * 14,
+                    text_y - 7,
+                    &I_More_data_placeholder_5x7);
+            } else {
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 8 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], false));
+            }
+        }
+
+        if(draw_index_line) {
+            canvas_draw_icon(canvas, 1, text_y + 8, &I_Hashmark_7x7);
+            canvas_draw_glyph(
+                canvas, text_x + 2 + byte_position * 14, text_y2, num_to_char[(i + 1) / 10]);
+
+            canvas_draw_glyph(
+                canvas, text_x + 8 + byte_position * 14, text_y2, num_to_char[(i + 1) % 10]);
+        }
+    }
+
+    if((model->selected_row == -2) &&
+       (model->first_visible_byte + MIN(model->bytes_count, max_drawable_bytes + 1) > 100)) {
+        char str[20];
+
+        canvas_set_font(canvas, FontSecondary);
+        snprintf(str, 20, "Selected index");
+        canvas_draw_str(canvas, text_x, text_y2, str);
+
+        canvas_set_font(canvas, FontPrimary);
+        snprintf(str, 20, "%u", (model->selected_byte + 1));
+        canvas_draw_str(canvas, text_x + 75, text_y2, str);
+    }
+}
+
+/** Draw input box (selected view)
+ *
+ * @param      canvas  The canvas
+ * @param      model   The model
+ */
+static void int_input_draw_input_selected(Canvas* canvas, IntInputModel* model) {
+    const uint8_t text_x = 7;
+    const uint8_t text_y = 25;
+
+    canvas_draw_box(canvas, 0, 12, 127, 19);
+    canvas_invert_color(canvas);
+
+    elements_slightly_rounded_frame(canvas, 6, 14, 115, 15);
+    canvas_draw_icon(canvas, 2, 19, &I_ButtonLeftSmall_3x5);
+    canvas_draw_icon(canvas, 122, 19, &I_ButtonRightSmall_3x5);
+
+    for(uint8_t i = model->first_visible_byte;
+        i < model->first_visible_byte + MIN(model->bytes_count, max_drawable_bytes);
+        i++) {
+        uint8_t byte_position = i - model->first_visible_byte;
+
+        if(i == model->selected_byte) {
+            canvas_draw_box(canvas, text_x + 1 + byte_position * 14, text_y - 9, 13, 11);
+            canvas_invert_color(canvas);
+            canvas_draw_glyph(
+                canvas,
+                text_x + 2 + byte_position * 14,
+                text_y,
+                int_input_get_nibble_text(model->bytes[i], true));
+            canvas_draw_glyph(
+                canvas,
+                text_x + 8 + byte_position * 14,
+                text_y,
+                int_input_get_nibble_text(model->bytes[i], false));
+            canvas_invert_color(canvas);
+        } else {
+            if(model->first_visible_byte > 0 && i == model->first_visible_byte) {
+                canvas_draw_icon(
+                    canvas,
+                    text_x + 2 + byte_position * 14,
+                    text_y - 7,
+                    &I_More_data_placeholder_5x7);
+            } else {
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 2 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], true));
+            }
+            if(model->bytes_count - model->first_visible_byte > max_drawable_bytes &&
+               i == model->first_visible_byte + MIN(model->bytes_count, max_drawable_bytes) - 1) {
+                canvas_draw_icon(
+                    canvas,
+                    text_x + 8 + byte_position * 14,
+                    text_y - 7,
+                    &I_More_data_placeholder_5x7);
+            } else {
+                canvas_draw_glyph(
+                    canvas,
+                    text_x + 8 + byte_position * 14,
+                    text_y,
+                    int_input_get_nibble_text(model->bytes[i], false));
+            }
+        }
+    }
+
+    canvas_invert_color(canvas);
+}
+
+/** Set nibble at position
+ *
+ * @param      data         where to set nibble
+ * @param      position     byte position
+ * @param      value        char value
+ * @param      high_nibble  set high nibble
+ */
+/*static void int_input_set_nibble(uint8_t* data, uint8_t position, char value, bool high_nibble) {
+    switch(value) {
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+        value = value - '0';
+        break;
+    case 'A':
+    case 'B':
+    case 'C':
+    case 'D':
+    case 'E':
+    case 'F':
+        value = value - 'A' + 10;
+        break;
+    default:
+        value = 0;
+        break;
+    }
+
+    if(high_nibble) {
+        data[position] &= 0x0F;
+        data[position] |= value << 4;
+    } else {
+        data[position] &= 0xF0;
+        data[position] |= value;
+    }
+}*/
+
+/** What currently selected
+ *
+ * @param      model  The model
+ *
+ * @return     true - keyboard selected, false - input selected
+ */
+static bool int_input_keyboard_selected(IntInputModel* model) {
+    return model->selected_row >= 0;
+}
+
+/** Do transition from keyboard
+ *
+ * @param      model  The model
+ */
+static void int_input_transition_from_keyboard(IntInputModel* model) {
+    model->selected_row += 1;
+    model->selected_high_nibble = true;
+}
+
+/** Increase selected byte position
+ *
+ * @param      model  The model
+ */
+static void int_input_inc_selected_byte(IntInputModel* model) {
+    if(model->selected_byte < model->bytes_count - 1) {
+        model->selected_byte += 1;
+
+        if(model->bytes_count > max_drawable_bytes) {
+            if(model->selected_byte - model->first_visible_byte > (max_drawable_bytes - 2)) {
+                if(model->first_visible_byte < model->bytes_count - max_drawable_bytes) {
+                    model->first_visible_byte++;
+                }
+            }
+        }
+    }
+}
+
+static void int_input_inc_selected_byte_mini(IntInputModel* model) {
+    if((model->selected_byte < model->bytes_count - 1) || model->selected_high_nibble) {
+        if(!model->selected_high_nibble) {
+            model->selected_high_nibble = !model->selected_high_nibble; //-V547
+            int_input_inc_selected_byte(model);
+        } else {
+            model->selected_high_nibble = !model->selected_high_nibble; //-V547
+        }
+    }
+}
+
+/** Decrease selected byte position
+ *
+ * @param      model  The model
+ */
+static void int_input_dec_selected_byte(IntInputModel* model) {
+    if(model->selected_byte > 0) {
+        model->selected_byte -= 1;
+
+        furi_assert(model->selected_byte >= model->first_visible_byte);
+        if(model->selected_byte - model->first_visible_byte < 1) {
+            if(model->first_visible_byte > 0) {
+                model->first_visible_byte--;
+            }
+        }
+    }
+}
+
+static void int_input_dec_selected_byte_mini(IntInputModel* model) {
+    if(model->selected_byte > 0 || !model->selected_high_nibble) {
+        if(model->selected_high_nibble) {
+            model->selected_high_nibble = !model->selected_high_nibble; //-V547
+            int_input_dec_selected_byte(model);
+        } else {
+            model->selected_high_nibble = !model->selected_high_nibble; //-V547
+        }
+    }
+}
+
+/** Call input callback
+ *
+ * @param      model  The model
+ */
+static void int_input_call_input_callback(IntInputModel* model) {
+    if(model->input_callback != NULL) {
+        model->input_callback(model->callback_context);
+    }
+}
+
+/** Call changed callback
+ *
+ * @param      model  The model
+ */
+static void int_input_call_changed_callback(IntInputModel* model) {
+    if(model->changed_callback != NULL) {
+        model->changed_callback(model->callback_context);
+    }
+}
+
+/** Clear selected byte
+ *
+ * @param      model  The model
+ */
+
+static void int_input_clear_selected_byte(IntInputModel* model) {
+    model->bytes[model->selected_byte] = 0;
+    model->selected_high_nibble = true;
+    int_input_dec_selected_byte(model);
+    int_input_call_changed_callback(model);
+}
+
+/** Handle up button
+ *
+ * @param      model  The model
+ */
+static void int_input_handle_up(IntInputModel* model) {
+    if(model->selected_row > -2) {
+        model->selected_row -= 1;
+    } else if(model->selected_row == -2) {
+        if(!model->selected_high_nibble) {
+            model->bytes[model->selected_byte] = (model->bytes[model->selected_byte] & 0xF0) |
+                                                 ((model->bytes[model->selected_byte] + 1) & 0x0F);
+        } else {
+            model->bytes[model->selected_byte] =
+                ((model->bytes[model->selected_byte] + 0x10) & 0xF0) |
+                (model->bytes[model->selected_byte] & 0x0F);
+        }
+        int_input_call_changed_callback(model);
+    }
+}
+
+/** Handle down button
+ *
+ * @param      model  The model
+ */
+static void int_input_handle_down(IntInputModel* model) {
+    if(model->selected_row != -2) {
+        if(int_input_keyboard_selected(model)) {
+            if(model->selected_row < keyboard_row_count - 1) {
+                model->selected_row += 1;
+            }
+        } else {
+            int_input_transition_from_keyboard(model);
+        }
+    } else {
+        if(!model->selected_high_nibble) {
+            model->bytes[model->selected_byte] = (model->bytes[model->selected_byte] & 0xF0) |
+                                                 ((model->bytes[model->selected_byte] - 1) & 0x0F);
+        } else {
+            model->bytes[model->selected_byte] =
+                ((model->bytes[model->selected_byte] - 0x10) & 0xF0) |
+                (model->bytes[model->selected_byte] & 0x0F);
+        }
+        int_input_call_changed_callback(model);
+    }
+}
+
+/** Handle left button
+ *
+ * @param      model  The model
+ */
+static void int_input_handle_left(IntInputModel* model) {
+    if(int_input_keyboard_selected(model)) {
+        if(model->selected_column > 0) {
+            model->selected_column -= 1;
+        } else {
+            model->selected_column = int_input_get_row_size(model->selected_row) - 1;
+        }
+    } else {
+        if(model->selected_row != -2) {
+            int_input_dec_selected_byte(model);
+        } else {
+            int_input_dec_selected_byte_mini(model);
+        }
+    }
+}
+
+/** Handle right button
+ *
+ * @param      model  The model
+ */
+static void int_input_handle_right(IntInputModel* model) {
+    if(int_input_keyboard_selected(model)) {
+        if(model->selected_column < int_input_get_row_size(model->selected_row) - 1) {
+            model->selected_column += 1;
+        } else {
+            model->selected_column = 0;
+        }
+    } else {
+        if(model->selected_row != -2) {
+            int_input_inc_selected_byte(model);
+        } else {
+            int_input_inc_selected_byte_mini(model);
+        }
+    }
+}
+
+/** Handle OK button
+ *
+ * @param      model  The model
+ */
+static void int_input_handle_ok(IntInputModel* model) {
+    if(int_input_keyboard_selected(model)) {
+        uint8_t value = int_input_get_row(model->selected_row)[model->selected_column].value;
+
+        if(value == enter_symbol) {
+            int_input_call_input_callback(model);
+        } else if(value == backspace_symbol) {
+            int_input_clear_selected_byte(model);
+        } else {
+            /*int_input_set_nibble(
+                model->bytes, model->selected_byte, value, model->selected_high_nibble);
+            if(model->selected_high_nibble == true) {
+                model->selected_high_nibble = false;
+            } else {
+                int_input_inc_selected_byte(model);
+                model->selected_high_nibble = true;
+            }
+            int_input_call_changed_callback(model);*/
+        }
+    } else if(model->selected_row == -2) {
+        int_input_call_input_callback(model);
+    } else {
+        int_input_transition_from_keyboard(model);
+    }
+}
+
+/** Draw callback
+ *
+ * @param      canvas  The canvas
+ * @param      _model  The model
+ */
+static void int_input_view_draw_callback(Canvas* canvas, void* _model) {
+    IntInputModel* model = _model;
+
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_set_font(canvas, FontKeyboard);
+
+    if(model->selected_row == -1) {
+        int_input_draw_input_selected(canvas, model);
+    } else {
+        int_input_draw_input(canvas, model);
+    }
+
+    if(model->selected_row == -2) {
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_icon(canvas, 3, 1, &I_Pin_back_arrow_10x8);
+        canvas_draw_str_aligned(canvas, 16, 9, AlignLeft, AlignBottom, "back to keyboard");
+        elements_button_center(canvas, "Save");
+    } else {
+        // Draw the header
+        canvas_set_font(canvas, FontSecondary);
+        if(model->selected_row == -1) {
+            canvas_draw_str(canvas, 10, 9, "Move up for alternate input");
+            canvas_draw_icon(canvas, 3, 4, &I_SmallArrowUp_3x5);
+        } else {
+            canvas_draw_str(canvas, 2, 9, model->header);
+        }
+        canvas_set_font(canvas, FontKeyboard);
+        // Draw keyboard
+        for(uint8_t row = 0; row < keyboard_row_count; row++) {
+            const uint8_t column_count = int_input_get_row_size(row);
+            const IntInputKey* keys = int_input_get_row(row);
+
+            for(size_t column = 0; column < column_count; column++) {
+                if(keys[column].value == enter_symbol) {
+                    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].value == backspace_symbol) {
+                    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 - 3,
+                            keyboard_origin_y + keys[column].y - 10,
+                            11,
+                            13);
+                        canvas_set_color(canvas, ColorWhite);
+                    } else if(
+                        model->selected_row == -1 && row == 0 &&
+                        model->selected_column == column) {
+                        canvas_set_color(canvas, ColorBlack);
+                        canvas_draw_frame(
+                            canvas,
+                            keyboard_origin_x + keys[column].x - 3,
+                            keyboard_origin_y + keys[column].y - 10,
+                            11,
+                            13);
+                    } else {
+                        canvas_set_color(canvas, ColorBlack);
+                    }
+
+                    canvas_draw_glyph(
+                        canvas,
+                        keyboard_origin_x + keys[column].x,
+                        keyboard_origin_y + keys[column].y,
+                        keys[column].value);
+                }
+            }
+        }
+    }
+}
+
+/** Input callback
+ *
+ * @param      event    The event
+ * @param      context  The context
+ *
+ * @return     true
+ * @return     false
+ */
+static bool int_input_view_input_callback(InputEvent* event, void* context) {
+    IntInput* int_input = context;
+    furi_assert(int_input);
+    bool consumed = false;
+
+    if(event->type == InputTypeShort || event->type == InputTypeRepeat) {
+        switch(event->key) {
+        case InputKeyLeft:
+            with_view_model(
+                int_input->view, IntInputModel * model, { int_input_handle_left(model); }, true);
+            consumed = true;
+            break;
+        case InputKeyRight:
+            with_view_model(
+                int_input->view,
+                IntInputModel * model,
+                { int_input_handle_right(model); },
+                true);
+            consumed = true;
+            break;
+        case InputKeyUp:
+            with_view_model(
+                int_input->view, IntInputModel * model, { int_input_handle_up(model); }, true);
+            consumed = true;
+            break;
+        case InputKeyDown:
+            with_view_model(
+                int_input->view, IntInputModel * model, { int_input_handle_down(model); }, true);
+            consumed = true;
+            break;
+        case InputKeyOk:
+            with_view_model(
+                int_input->view, IntInputModel * model, { int_input_handle_ok(model); }, true);
+            consumed = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+    if(event->type == InputTypeShort && event->key == InputKeyBack) {
+        // Back to keyboard
+        with_view_model(
+            int_input->view,
+            IntInputModel * model,
+            {
+                if(model->selected_row == -2) {
+                    model->selected_row += 1;
+                    consumed = true;
+                };
+            },
+            true);
+    }
+
+    if((event->type == InputTypeLong || event->type == InputTypeRepeat) &&
+       event->key == InputKeyBack) {
+        with_view_model(
+            int_input->view,
+            IntInputModel * model,
+            { int_input_clear_selected_byte(model); },
+            true);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+/** Reset all input-related data in model
+ *
+ * @param      model  The model
+ */
+static void int_input_reset_model_input_data(IntInputModel* model) {
+    model->bytes = NULL;
+    model->bytes_count = 0;
+    model->selected_high_nibble = true;
+    model->selected_byte = 0;
+    model->selected_row = 0;
+    model->selected_column = 0;
+    model->first_visible_byte = 0;
+}
+
+IntInput* int_input_alloc() {
+    IntInput* int_input = malloc(sizeof(IntInput));
+    int_input->view = view_alloc();
+    view_set_context(int_input->view, int_input);
+    view_allocate_model(int_input->view, ViewModelTypeLocking, sizeof(IntInputModel));
+    view_set_draw_callback(int_input->view, int_input_view_draw_callback);
+    view_set_input_callback(int_input->view, int_input_view_input_callback);
+
+    with_view_model(
+        int_input->view,
+        IntInputModel * model,
+        {
+            model->header = "";
+            model->input_callback = NULL;
+            model->changed_callback = NULL;
+            model->callback_context = NULL;
+            int_input_reset_model_input_data(model);
+        },
+        true);
+
+    return int_input;
+}
+
+void int_input_free(IntInput* int_input) {
+    furi_assert(int_input);
+    view_free(int_input->view);
+    free(int_input);
+}
+
+View* int_input_get_view(IntInput* int_input) {
+    furi_assert(int_input);
+    return int_input->view;
+}
+
+void int_input_set_result_callback(
+    IntInput* int_input,
+    IntInputCallback input_callback,
+    IntChangedCallback changed_callback,
+    void* callback_context,
+    uint8_t* bytes,
+    uint8_t bytes_count) {
+    with_view_model(
+        int_input->view,
+        IntInputModel * model,
+        {
+            int_input_reset_model_input_data(model);
+            model->input_callback = input_callback;
+            model->changed_callback = changed_callback;
+            model->callback_context = callback_context;
+            model->bytes = bytes;
+            model->bytes_count = bytes_count;
+        },
+        true);
+}
+
+void int_input_set_header_text(IntInput* int_input, const char* text) {
+    with_view_model(
+        int_input->view, IntInputModel * model, { model->header = text; }, true);
+}

helpers/gui/int_input.h

@@ -0,0 +1,69 @@
+/**
+ * @file int_input.h
+ * GUI: Integer keyboard view module API
+ */
+
+#pragma once
+
+#include <gui/view.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Int input anonymous structure  */
+typedef struct IntInput IntInput;
+
+/** callback that is executed on save button press */
+typedef void (*IntInputCallback)(void* context);
+
+/** callback that is executed when byte buffer is changed */
+typedef void (*IntChangedCallback)(void* context);
+
+/** Allocate and initialize Int input. This Int input is used to enter Ints.
+ *
+ * @return     IntInput instance pointer
+ */
+IntInput* int_input_alloc();
+
+/** Deinitialize and free byte input
+ *
+ * @param      int_input  Int input instance
+ */
+void int_input_free(IntInput* int_input);
+
+/** Get byte input view
+ *
+ * @param      int_input  byte input instance
+ *
+ * @return     View instance that can be used for embedding
+ */
+View* int_input_get_view(IntInput* int_input);
+
+/** Set byte input result callback
+ *
+ * @param      int_input        byte input instance
+ * @param      input_callback    input callback fn
+ * @param      changed_callback  changed callback fn
+ * @param      callback_context  callback context
+ * @param      bytes             buffer to use
+ * @param      bytes_count       buffer length
+ */
+void int_input_set_result_callback(
+    IntInput* int_input,
+    IntInputCallback input_callback,
+    IntChangedCallback changed_callback,
+    void* callback_context,
+    uint8_t* bytes,
+    uint8_t bytes_count);
+
+/** Set byte input header text
+ *
+ * @param      int_input  byte input instance
+ * @param      text        text to be shown
+ */
+void int_input_set_header_text(IntInput* int_input, const char* text);
+
+#ifdef __cplusplus
+}
+#endif

helpers/meal_pager_custom_event.h

@@ -23,6 +23,7 @@ typedef enum {
     Meal_PagerCustomEventViewTransmitterSendStart,
     Meal_PagerCustomEventViewTransmitterSendStop,
     Meal_PagerCustomEventViewTransmitterError,
+    Meal_PagerCustomerEventIntInput,
 } Meal_PagerCustomEvent;
 
 enum Meal_PagerCustomEventType {

meal_pager.c

@@ -58,6 +58,8 @@ Meal_Pager* meal_pager_app_alloc() {
     app->stop_transmit = false;
     app->repeats = 1;
     app->repeats_char = "1";
+    app->max_station = 8191;
+    app->max_pager = 999;
 
     // Used for File Browser
     app->dialogs = furi_record_open(RECORD_DIALOGS);
@@ -65,6 +67,9 @@ Meal_Pager* meal_pager_app_alloc() {
 
     app->subghz = subghz_alloc();
 
+    // Custom made int keyboard
+    app->int_input = int_input_alloc();
+
     // Load configs
     meal_pager_read_settings(app);
 
@@ -87,6 +92,12 @@ Meal_Pager* meal_pager_app_alloc() {
         Meal_PagerViewIdSettings,
         variable_item_list_get_view(app->variable_item_list));
 
+    app->int_input = int_input_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, 
+        Meal_PagerViewIdIntInput, 
+        int_input_get_view(app->int_input));
+
     //End Scene Additions
 
     return app;
@@ -102,7 +113,9 @@ void meal_pager_app_free(Meal_Pager* app) {
     view_dispatcher_remove_view(app->view_dispatcher, Meal_PagerViewIdMenu);
     view_dispatcher_remove_view(app->view_dispatcher, Meal_PagerViewIdTransmit);
     view_dispatcher_remove_view(app->view_dispatcher, Meal_PagerViewIdSettings);
+    view_dispatcher_remove_view(app->view_dispatcher, Meal_PagerViewIdIntInput);
     submenu_free(app->submenu);
+    int_input_free(app->int_input);
 
     view_dispatcher_free(app->view_dispatcher);
     furi_record_close(RECORD_GUI);

meal_pager.h

@@ -1,2 +1,2 @@
 #pragma once
-#include "meal_pager_i.h"
+#include "meal_pager_i.h"

meal_pager_i.h

@@ -19,6 +19,7 @@
 #include "helpers/meal_pager_storage.h"
 #include "helpers/subghz/subghz_types.h"
 #include "helpers/subghz/subghz.h"
+#include "helpers/gui/int_input.h"
 
 #define TAG "Meal_Pager"
 
@@ -59,6 +60,10 @@ typedef struct {
     bool stop_transmit;
     uint32_t repeats;
     char* repeats_char;
+    IntInput* int_input;
+    char* text_buffer;
+    uint32_t max_station;
+    uint32_t max_pager;
 } Meal_Pager;
 
 typedef enum {
@@ -66,6 +71,7 @@ typedef enum {
     Meal_PagerViewIdMenu,
     Meal_PagerViewIdTransmit,
     Meal_PagerViewIdSettings,
+    Meal_PagerViewIdIntInput,
 } Meal_PagerViewId;
 
 typedef enum {

scenes/meal_pager_scene_config.h

@@ -1,4 +1,5 @@
 ADD_SCENE(meal_pager, startscreen, Startscreen)
 ADD_SCENE(meal_pager, menu, Menu)
 ADD_SCENE(meal_pager, transmit, Transmit)
-ADD_SCENE(meal_pager, settings, Settings)
+ADD_SCENE(meal_pager, settings, Settings)
+ADD_SCENE(meal_pager, set_station, SetStation)

scenes/meal_pager_scene_menu.c

@@ -4,7 +4,7 @@
 
 enum SubmenuIndex {
     SubmenuIndexTransmit = 10,
-    SubmenuIndexScene2,
+    SubmenuIndexSetStation,
     SubmenuIndexScene3,
     SubmenuIndexScene4,
     SubmenuIndexScene5,
@@ -25,6 +25,12 @@ void meal_pager_scene_menu_on_enter(void* context) {
         SubmenuIndexTransmit,
         meal_pager_scene_menu_submenu_callback,
         app);
+    submenu_add_item(
+        app->submenu,
+        "Set Stations",
+        SubmenuIndexSetStation,
+        meal_pager_scene_menu_submenu_callback,
+        app);    
     submenu_add_item(
         app->submenu,
         "Settings",
@@ -62,6 +68,11 @@ bool meal_pager_scene_menu_on_event(void* context, SceneManagerEvent event) {
             subghz_txrx_stop(app->subghz->txrx);
             FURI_LOG_D(TAG, "Stop Event from Menu");
             return true;
+        } else if(event.event == SubmenuIndexSetStation) {
+            scene_manager_set_scene_state(
+                app->scene_manager, Meal_PagerSceneSetStation, SubmenuIndexSetStation);
+            scene_manager_next_scene(app->scene_manager, Meal_PagerSceneSetStation);
+            return true;
         }
     } else if(event.type == SceneManagerEventTypeTick) {
         if(app->state_notifications == SubGhzNotificationStateTx) {

scenes/meal_pager_scene_set_station.c

@@ -0,0 +1,86 @@
+#include "../meal_pager_i.h"
+#include "../helpers/meal_pager_custom_event.h"
+#include "../helpers/retekess/meal_pager_retekess_t119.h"
+#include "../helpers/retekess/meal_pager_retekess_td157.h"
+#include "../helpers/retekess/meal_pager_retekess_td165.h"
+#include "../helpers/retekess/meal_pager_retekess_td174.h"
+#include "../views/meal_pager_transmit.h"
+#include "../helpers/meal_pager_led.h"
+#include "../helpers/subghz/subghz.h"
+#include "../views/meal_pager_transmit.h"
+#include <dolphin/dolphin.h>
+
+void meal_pager_set_station_callback(Meal_PagerCustomEvent event, void* context) {
+    furi_assert(context);
+    Meal_Pager* app = context;
+    
+    UNUSED(app);
+    UNUSED(event);
+}
+
+/*static void meal_pager_int_input_callback(void* context) {
+    furi_assert(context);
+    Meal_Pager* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, Meal_PagerCustomerEventIntInput);
+}*/
+
+void meal_pager_scene_set_station_on_enter(void* context) {
+    furi_assert(context);
+    Meal_Pager* app = context;
+    IntInput* int_input = app->int_input;
+    uint8_t enter_name_length = 4;
+
+    int_input_set_header_text(int_input, "Set first Station (0 - 8191)");
+
+    /*int_input_set_result_callback(
+        int_input,
+        meal_pager_int_input_callback,
+        context,
+        app->text_buffer,
+        &enter_name_length,
+        false);*/
+        
+    UNUSED(app);
+    UNUSED(enter_name_length);
+    view_dispatcher_switch_to_view(app->view_dispatcher, Meal_PagerViewIdIntInput);
+}
+
+
+bool meal_pager_scene_set_station_on_event(void* context, SceneManagerEvent event) {
+    Meal_Pager* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case Meal_PagerCustomEventTransmitLeft:
+        case Meal_PagerCustomEventTransmitRight:
+            break;
+        case Meal_PagerCustomEventTransmitUp:
+        case Meal_PagerCustomEventTransmitDown:
+            break;
+        case Meal_PagerCustomEventTransmitBack:
+            if(!scene_manager_search_and_switch_to_previous_scene(
+                   app->scene_manager, Meal_PagerSceneMenu)) {
+                scene_manager_stop(app->scene_manager);
+                view_dispatcher_stop(app->view_dispatcher);
+            }
+            consumed = true;
+            break;
+        }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        if(app->state_notifications == SubGhzNotificationStateTx) {
+            app->state_notifications = SubGhzNotificationStateIDLE;
+            subghz_txrx_stop(app->subghz->txrx);
+            meal_pager_blink_stop(app);
+            meal_pager_transmit_model_set_sending(app->meal_pager_transmit, 0);
+        }
+        return true;
+    }
+
+    return consumed;
+}
+
+void meal_pager_scene_set_station_on_exit(void* context) {
+    Meal_Pager* app = context;
+    UNUSED(app);
+}