From b11b9f1b38407d22e31443f4e84a20c079923a24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E3=81=82=E3=81=8F?= Date: Thu, 29 Dec 2022 20:35:26 +0900 Subject: [PATCH 1/2] Gui: Direct Draw API (#2215) * Furi: allow on-fly thread priority change. Gui: Direct Draw API. DirectDraw debug app. * Gui: drop input in direct draw * Furi: handle priority change for starting threads * DirectDraw: rollback to FreeRTOS primitives for priority change --- .../debug/direct_draw/application.fam | 10 ++ applications/debug/direct_draw/direct_draw.c | 112 +++++++++++++ applications/services/gui/canvas.h | 12 ++ applications/services/gui/canvas_i.h | 12 -- applications/services/gui/gui.c | 154 +++++++++++------- applications/services/gui/gui.h | 22 +++ applications/services/gui/gui_i.h | 1 + firmware/targets/f7/api_symbols.csv | 6 +- 8 files changed, 258 insertions(+), 71 deletions(-) create mode 100644 applications/debug/direct_draw/application.fam create mode 100644 applications/debug/direct_draw/direct_draw.c diff --git a/applications/debug/direct_draw/application.fam b/applications/debug/direct_draw/application.fam new file mode 100644 index 000000000..11b3bc6ba --- /dev/null +++ b/applications/debug/direct_draw/application.fam @@ -0,0 +1,10 @@ +App( + appid="direct_draw", + name="Direct Draw", + apptype=FlipperAppType.DEBUG, + entry_point="direct_draw_app", + requires=["gui", "input"], + stack_size=2 * 1024, + order=70, + fap_category="Debug", +) diff --git a/applications/debug/direct_draw/direct_draw.c b/applications/debug/direct_draw/direct_draw.c new file mode 100644 index 000000000..71c65eab1 --- /dev/null +++ b/applications/debug/direct_draw/direct_draw.c @@ -0,0 +1,112 @@ +#include +#include +#include +#include + +#define BUFFER_SIZE (32U) + +typedef struct { + FuriPubSub* input; + FuriPubSubSubscription* input_subscription; + Gui* gui; + Canvas* canvas; + bool stop; + uint32_t counter; +} DirectDraw; + +static void gui_input_events_callback(const void* value, void* ctx) { + furi_assert(value); + furi_assert(ctx); + + DirectDraw* instance = ctx; + const InputEvent* event = value; + + if(event->key == InputKeyBack && event->type == InputTypeShort) { + instance->stop = true; + } +} + +static DirectDraw* direct_draw_alloc() { + DirectDraw* instance = malloc(sizeof(DirectDraw)); + + instance->input = furi_record_open(RECORD_INPUT_EVENTS); + instance->gui = furi_record_open(RECORD_GUI); + instance->canvas = gui_direct_draw_acquire(instance->gui); + + instance->input_subscription = + furi_pubsub_subscribe(instance->input, gui_input_events_callback, instance); + + return instance; +} + +static void direct_draw_free(DirectDraw* instance) { + furi_pubsub_unsubscribe(instance->input, instance->input_subscription); + + instance->canvas = NULL; + gui_direct_draw_release(instance->gui); + furi_record_close(RECORD_GUI); + furi_record_close(RECORD_INPUT_EVENTS); +} + +static void direct_draw_block(Canvas* canvas, uint32_t size, uint32_t counter) { + size += 16; + uint8_t width = canvas_width(canvas) - size; + uint8_t height = canvas_height(canvas) - size; + + uint8_t x = counter % width; + if((counter / width) % 2) { + x = width - x; + } + + uint8_t y = counter % height; + if((counter / height) % 2) { + y = height - y; + } + + canvas_draw_box(canvas, x, y, size, size); +} + +static void direct_draw_run(DirectDraw* instance) { + size_t start = DWT->CYCCNT; + size_t counter = 0; + float fps = 0; + + vTaskPrioritySet(furi_thread_get_current_id(), FuriThreadPriorityIdle); + + do { + size_t elapsed = DWT->CYCCNT - start; + char buffer[BUFFER_SIZE] = {0}; + + if(elapsed >= 64000000) { + fps = (float)counter / ((float)elapsed / 64000000.0f); + + start = DWT->CYCCNT; + counter = 0; + } + snprintf(buffer, BUFFER_SIZE, "FPS: %.1f", (double)fps); + + canvas_reset(instance->canvas); + canvas_set_color(instance->canvas, ColorXOR); + direct_draw_block(instance->canvas, instance->counter % 16, instance->counter); + direct_draw_block(instance->canvas, instance->counter * 2 % 16, instance->counter * 2); + direct_draw_block(instance->canvas, instance->counter * 3 % 16, instance->counter * 3); + direct_draw_block(instance->canvas, instance->counter * 4 % 16, instance->counter * 4); + direct_draw_block(instance->canvas, instance->counter * 5 % 16, instance->counter * 5); + canvas_draw_str(instance->canvas, 10, 10, buffer); + canvas_commit(instance->canvas); + + counter++; + instance->counter++; + furi_thread_yield(); + } while(!instance->stop); +} + +int32_t direct_draw_app(void* p) { + UNUSED(p); + + DirectDraw* instance = direct_draw_alloc(); + direct_draw_run(instance); + direct_draw_free(instance); + + return 0; +} diff --git a/applications/services/gui/canvas.h b/applications/services/gui/canvas.h index c4eb8649f..0b0c7e658 100644 --- a/applications/services/gui/canvas.h +++ b/applications/services/gui/canvas.h @@ -67,6 +67,18 @@ typedef struct { /** Canvas anonymous structure */ typedef struct Canvas Canvas; +/** Reset canvas drawing tools configuration + * + * @param canvas Canvas instance + */ +void canvas_reset(Canvas* canvas); + +/** Commit canvas. Send buffer to display + * + * @param canvas Canvas instance + */ +void canvas_commit(Canvas* canvas); + /** Get Canvas width * * @param canvas Canvas instance diff --git a/applications/services/gui/canvas_i.h b/applications/services/gui/canvas_i.h index d5594c24a..2b6849235 100644 --- a/applications/services/gui/canvas_i.h +++ b/applications/services/gui/canvas_i.h @@ -31,18 +31,6 @@ Canvas* canvas_init(); */ void canvas_free(Canvas* canvas); -/** Reset canvas drawing tools configuration - * - * @param canvas Canvas instance - */ -void canvas_reset(Canvas* canvas); - -/** Commit canvas. Send buffer to display - * - * @param canvas Canvas instance - */ -void canvas_commit(Canvas* canvas); - /** Get canvas buffer. * * @param canvas Canvas instance diff --git a/applications/services/gui/gui.c b/applications/services/gui/gui.c index 9f6ebcd76..b0903e021 100644 --- a/applications/services/gui/gui.c +++ b/applications/services/gui/gui.c @@ -20,7 +20,7 @@ ViewPort* gui_view_port_find_enabled(ViewPortArray_t array) { void gui_update(Gui* gui) { furi_assert(gui); - furi_thread_flags_set(gui->thread_id, GUI_THREAD_FLAG_DRAW); + if(!gui->direct_draw) furi_thread_flags_set(gui->thread_id, GUI_THREAD_FLAG_DRAW); } void gui_input_events_callback(const void* value, void* ctx) { @@ -34,7 +34,7 @@ void gui_input_events_callback(const void* value, void* ctx) { } // Only Fullscreen supports vertical display for now -bool gui_redraw_fs(Gui* gui) { +static bool gui_redraw_fs(Gui* gui) { canvas_set_orientation(gui->canvas, CanvasOrientationHorizontal); canvas_frame_set(gui->canvas, 0, 0, GUI_DISPLAY_WIDTH, GUI_DISPLAY_HEIGHT); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]); @@ -192,7 +192,7 @@ static void gui_redraw_status_bar(Gui* gui, bool need_attention) { } } -bool gui_redraw_window(Gui* gui) { +static bool gui_redraw_window(Gui* gui) { canvas_set_orientation(gui->canvas, CanvasOrientationHorizontal); canvas_frame_set(gui->canvas, GUI_WINDOW_X, GUI_WINDOW_Y, GUI_WINDOW_WIDTH, GUI_WINDOW_HEIGHT); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerWindow]); @@ -203,7 +203,7 @@ bool gui_redraw_window(Gui* gui) { return false; } -bool gui_redraw_desktop(Gui* gui) { +static bool gui_redraw_desktop(Gui* gui) { canvas_set_orientation(gui->canvas, CanvasOrientationHorizontal); canvas_frame_set(gui->canvas, 0, 0, GUI_DISPLAY_WIDTH, GUI_DISPLAY_HEIGHT); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]); @@ -215,37 +215,44 @@ bool gui_redraw_desktop(Gui* gui) { return false; } -void gui_redraw(Gui* gui) { +static void gui_redraw(Gui* gui) { furi_assert(gui); gui_lock(gui); - canvas_reset(gui->canvas); + do { + if(gui->direct_draw) break; - if(gui->lockdown) { - gui_redraw_desktop(gui); - bool need_attention = - (gui_view_port_find_enabled(gui->layers[GuiLayerWindow]) != 0 || - gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]) != 0); - gui_redraw_status_bar(gui, need_attention); - } else { - if(!gui_redraw_fs(gui)) { - if(!gui_redraw_window(gui)) { - gui_redraw_desktop(gui); + canvas_reset(gui->canvas); + + if(gui->lockdown) { + gui_redraw_desktop(gui); + bool need_attention = + (gui_view_port_find_enabled(gui->layers[GuiLayerWindow]) != 0 || + gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]) != 0); + gui_redraw_status_bar(gui, need_attention); + } else { + if(!gui_redraw_fs(gui)) { + if(!gui_redraw_window(gui)) { + gui_redraw_desktop(gui); + } + gui_redraw_status_bar(gui, false); } - gui_redraw_status_bar(gui, false); } - } - canvas_commit(gui->canvas); - for - M_EACH(p, gui->canvas_callback_pair, CanvasCallbackPairArray_t) { - p->callback( - canvas_get_buffer(gui->canvas), canvas_get_buffer_size(gui->canvas), p->context); - } + canvas_commit(gui->canvas); + for + M_EACH(p, gui->canvas_callback_pair, CanvasCallbackPairArray_t) { + p->callback( + canvas_get_buffer(gui->canvas), + canvas_get_buffer_size(gui->canvas), + p->context); + } + } while(false); + gui_unlock(gui); } -void gui_input(Gui* gui, InputEvent* input_event) { +static void gui_input(Gui* gui, InputEvent* input_event) { furi_assert(gui); furi_assert(input_event); @@ -267,42 +274,48 @@ void gui_input(Gui* gui, InputEvent* input_event) { gui_lock(gui); - ViewPort* view_port = NULL; + do { + if(gui->direct_draw && !gui->ongoing_input_view_port) { + break; + } - if(gui->lockdown) { - view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]); - } else { - view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]); - if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerWindow]); - if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]); - } + ViewPort* view_port = NULL; - if(!(gui->ongoing_input & ~key_bit) && input_event->type == InputTypePress) { - gui->ongoing_input_view_port = view_port; - } + if(gui->lockdown) { + view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]); + } else { + view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]); + if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerWindow]); + if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerDesktop]); + } - if(view_port && view_port == gui->ongoing_input_view_port) { - view_port_input(view_port, input_event); - } else if(gui->ongoing_input_view_port && input_event->type == InputTypeRelease) { - FURI_LOG_D( - TAG, - "ViewPort changed while key press %p -> %p. Sending key: %s, type: %s, sequence: %p to previous view port", - gui->ongoing_input_view_port, - view_port, - input_get_key_name(input_event->key), - input_get_type_name(input_event->type), - (void*)input_event->sequence); - view_port_input(gui->ongoing_input_view_port, input_event); - } else { - FURI_LOG_D( - TAG, - "ViewPort changed while key press %p -> %p. Discarding key: %s, type: %s, sequence: %p", - gui->ongoing_input_view_port, - view_port, - input_get_key_name(input_event->key), - input_get_type_name(input_event->type), - (void*)input_event->sequence); - } + if(!(gui->ongoing_input & ~key_bit) && input_event->type == InputTypePress) { + gui->ongoing_input_view_port = view_port; + } + + if(view_port && view_port == gui->ongoing_input_view_port) { + view_port_input(view_port, input_event); + } else if(gui->ongoing_input_view_port && input_event->type == InputTypeRelease) { + FURI_LOG_D( + TAG, + "ViewPort changed while key press %p -> %p. Sending key: %s, type: %s, sequence: %p to previous view port", + gui->ongoing_input_view_port, + view_port, + input_get_key_name(input_event->key), + input_get_type_name(input_event->type), + (void*)input_event->sequence); + view_port_input(gui->ongoing_input_view_port, input_event); + } else { + FURI_LOG_D( + TAG, + "ViewPort changed while key press %p -> %p. Discarding key: %s, type: %s, sequence: %p", + gui->ongoing_input_view_port, + view_port, + input_get_key_name(input_event->key), + input_get_type_name(input_event->type), + (void*)input_event->sequence); + } + } while(false); gui_unlock(gui); } @@ -471,6 +484,31 @@ void gui_set_lockdown(Gui* gui, bool lockdown) { gui_update(gui); } +Canvas* gui_direct_draw_acquire(Gui* gui) { + furi_assert(gui); + gui_lock(gui); + gui->direct_draw = true; + gui_unlock(gui); + + canvas_reset(gui->canvas); + canvas_commit(gui->canvas); + + return gui->canvas; +} + +void gui_direct_draw_release(Gui* gui) { + furi_assert(gui); + + canvas_reset(gui->canvas); + canvas_commit(gui->canvas); + + gui_lock(gui); + gui->direct_draw = false; + gui_unlock(gui); + + gui_update(gui); +} + Gui* gui_alloc() { Gui* gui = malloc(sizeof(Gui)); // Thread ID diff --git a/applications/services/gui/gui.h b/applications/services/gui/gui.h index f48867588..4e7fc2e4d 100644 --- a/applications/services/gui/gui.h +++ b/applications/services/gui/gui.h @@ -106,6 +106,28 @@ size_t gui_get_framebuffer_size(Gui* gui); */ void gui_set_lockdown(Gui* gui, bool lockdown); +/** Acquire Direct Draw lock and get Canvas instance + * + * This method return Canvas instance for use in monopoly mode. Direct draw lock + * disables input and draw call dispatch functions in GUI service. No other + * applications or services will be able to draw until gui_direct_draw_release + * call. + * + * @param gui The graphical user interface + * + * @return Canvas instance + */ +Canvas* gui_direct_draw_acquire(Gui* gui); + +/** Release Direct Draw Lock + * + * Release Direct Draw Lock, enables Input and Draw call processing. Canvas + * acquired in gui_direct_draw_acquire will become invalid after this call. + * + * @param gui Gui instance + */ +void gui_direct_draw_release(Gui* gui); + #ifdef __cplusplus } #endif diff --git a/applications/services/gui/gui_i.h b/applications/services/gui/gui_i.h index b3fd0aa7c..45061bd58 100644 --- a/applications/services/gui/gui_i.h +++ b/applications/services/gui/gui_i.h @@ -62,6 +62,7 @@ struct Gui { // Layers and Canvas bool lockdown; + bool direct_draw; ViewPortArray_t layers[GuiLayerMAX]; Canvas* canvas; CanvasCallbackPairArray_t canvas_callback_pair; diff --git a/firmware/targets/f7/api_symbols.csv b/firmware/targets/f7/api_symbols.csv index 28442b5ca..b41e18721 100644 --- a/firmware/targets/f7/api_symbols.csv +++ b/firmware/targets/f7/api_symbols.csv @@ -1,5 +1,5 @@ entry,status,name,type,params -Version,+,11.3,, +Version,+,11.4,, Header,+,applications/services/bt/bt_service/bt.h,, Header,+,applications/services/cli/cli.h,, Header,+,applications/services/cli/cli_vcp.h,, @@ -593,6 +593,7 @@ Function,+,byte_input_set_result_callback,void,"ByteInput*, ByteInputCallback, B Function,-,bzero,void,"void*, size_t" Function,-,calloc,void*,"size_t, size_t" Function,+,canvas_clear,void,Canvas* +Function,+,canvas_commit,void,Canvas* Function,+,canvas_current_font_height,uint8_t,Canvas* Function,+,canvas_draw_bitmap,void,"Canvas*, uint8_t, uint8_t, uint8_t, uint8_t, const uint8_t*" Function,+,canvas_draw_box,void,"Canvas*, uint8_t, uint8_t, uint8_t, uint8_t" @@ -614,6 +615,7 @@ Function,+,canvas_get_font_params,CanvasFontParameters*,"Canvas*, Font" Function,+,canvas_glyph_width,uint8_t,"Canvas*, char" Function,+,canvas_height,uint8_t,Canvas* Function,+,canvas_invert_color,void,Canvas* +Function,+,canvas_reset,void,Canvas* Function,+,canvas_set_bitmap_mode,void,"Canvas*, _Bool" Function,+,canvas_set_color,void,"Canvas*, Color" Function,+,canvas_set_font,void,"Canvas*, Font" @@ -1554,6 +1556,8 @@ Function,-,gmtime,tm*,const time_t* Function,-,gmtime_r,tm*,"const time_t*, tm*" Function,+,gui_add_framebuffer_callback,void,"Gui*, GuiCanvasCommitCallback, void*" Function,+,gui_add_view_port,void,"Gui*, ViewPort*, GuiLayer" +Function,+,gui_direct_draw_acquire,Canvas*,Gui* +Function,+,gui_direct_draw_release,void,Gui* Function,+,gui_get_framebuffer_size,size_t,Gui* Function,+,gui_remove_framebuffer_callback,void,"Gui*, GuiCanvasCommitCallback, void*" Function,+,gui_remove_view_port,void,"Gui*, ViewPort*" From 06cf1bb86813adf132eca1b270f27ab541b34449 Mon Sep 17 00:00:00 2001 From: Avery <30564701+nullableVoidPtr@users.noreply.github.com> Date: Fri, 30 Dec 2022 11:44:07 +0800 Subject: [PATCH 2/2] Gui: change data ownership model in submenu, own text by default (#2217) * GUI: Refactor submenu to internally use FuriStrings * NFC: Rework DESFIRE dynamic info submenu * GUI: don't mutate label when drawing submenu * Get rid of submenu_add_item_cstr * increase api version * Get rid of submenu_set_header_cstr * rollback api version * Documentation * RFID: use new submenu api Co-authored-by: Sergey Gavrilov --- .../lfrfid/scenes/lfrfid_scene_save_type.c | 17 ++--- .../nfc/scenes/nfc_scene_mf_desfire_app.c | 21 ++--- .../nfc/scenes/nfc_scene_mf_desfire_data.c | 21 +++-- applications/services/gui/modules/submenu.c | 76 +++++++++++++++---- 4 files changed, 84 insertions(+), 51 deletions(-) diff --git a/applications/main/lfrfid/scenes/lfrfid_scene_save_type.c b/applications/main/lfrfid/scenes/lfrfid_scene_save_type.c index 0ba51f066..dd20ae489 100644 --- a/applications/main/lfrfid/scenes/lfrfid_scene_save_type.c +++ b/applications/main/lfrfid/scenes/lfrfid_scene_save_type.c @@ -1,7 +1,6 @@ #include "../lfrfid_i.h" typedef struct { - FuriString* menu_item_name[LFRFIDProtocolMax]; uint32_t line_sel; } SaveTypeCtx; @@ -16,25 +15,27 @@ void lfrfid_scene_save_type_on_enter(void* context) { Submenu* submenu = app->submenu; SaveTypeCtx* state = malloc(sizeof(SaveTypeCtx)); + FuriString* protocol_string = furi_string_alloc(); for(uint8_t i = 0; i < LFRFIDProtocolMax; i++) { if(strcmp( protocol_dict_get_manufacturer(app->dict, i), protocol_dict_get_name(app->dict, i)) != 0) { - state->menu_item_name[i] = furi_string_alloc_printf( + furi_string_printf( + protocol_string, "%s %s", protocol_dict_get_manufacturer(app->dict, i), protocol_dict_get_name(app->dict, i)); } else { - state->menu_item_name[i] = - furi_string_alloc_printf("%s", protocol_dict_get_name(app->dict, i)); + furi_string_printf(protocol_string, "%s", protocol_dict_get_name(app->dict, i)); } submenu_add_item( submenu, - furi_string_get_cstr(state->menu_item_name[i]), + furi_string_get_cstr(protocol_string), i, lfrfid_scene_save_type_submenu_callback, app); } + furi_string_free(protocol_string); submenu_set_selected_item( submenu, scene_manager_get_scene_state(app->scene_manager, LfRfidSceneSaveType)); @@ -73,13 +74,7 @@ void lfrfid_scene_save_type_on_exit(void* context) { submenu_reset(app->submenu); - for(uint8_t i = 0; i < LFRFIDProtocolMax; i++) { - furi_string_free(state->menu_item_name[i]); - } - uint32_t line_sel = state->line_sel; - free(state); - scene_manager_set_scene_state(app->scene_manager, LfRfidSceneSaveType, line_sel); } diff --git a/applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c b/applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c index afc5f0dee..882dc5fea 100644 --- a/applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c +++ b/applications/main/nfc/scenes/nfc_scene_mf_desfire_app.c @@ -51,23 +51,18 @@ void nfc_scene_mf_desfire_app_on_enter(void* context) { nfc_scene_mf_desfire_app_submenu_callback, nfc); - uint16_t cap = NFC_TEXT_STORE_SIZE; - char* buf = nfc->text_store; + FuriString* label = furi_string_alloc(); int idx = SubmenuIndexDynamic; for(MifareDesfireFile* file = app->file_head; file; file = file->next) { - int size = snprintf(buf, cap, "File %d", file->id); - if(size < 0 || size >= cap) { - FURI_LOG_W( - TAG, - "Exceeded NFC_TEXT_STORE_SIZE when preparing file id strings; menu truncated"); - break; - } - char* label = buf; - cap -= size + 1; - buf += size + 1; + furi_string_printf(label, "File %d", file->id); submenu_add_item( - nfc->submenu, label, idx++, nfc_scene_mf_desfire_app_submenu_callback, nfc); + nfc->submenu, + furi_string_get_cstr(label), + idx++, + nfc_scene_mf_desfire_app_submenu_callback, + nfc); } + furi_string_free(label); view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu); } diff --git a/applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c b/applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c index e619d0377..c7caee8dc 100644 --- a/applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c +++ b/applications/main/nfc/scenes/nfc_scene_mf_desfire_data.c @@ -33,21 +33,18 @@ void nfc_scene_mf_desfire_data_on_enter(void* context) { nfc_scene_mf_desfire_data_submenu_callback, nfc); - uint16_t cap = NFC_TEXT_STORE_SIZE; - char* buf = nfc->text_store; + FuriString* label = furi_string_alloc(); int idx = SubmenuIndexDynamic; for(MifareDesfireApplication* app = data->app_head; app; app = app->next) { - int size = snprintf(buf, cap, "App %02x%02x%02x", app->id[0], app->id[1], app->id[2]); - if(size < 0 || size >= cap) { - FURI_LOG_W( - TAG, "Exceeded NFC_TEXT_STORE_SIZE when preparing app id strings; menu truncated"); - break; - } - char* label = buf; - cap -= size + 1; - buf += size + 1; - submenu_add_item(submenu, label, idx++, nfc_scene_mf_desfire_data_submenu_callback, nfc); + furi_string_printf(label, "App %02x%02x%02x", app->id[0], app->id[1], app->id[2]); + submenu_add_item( + submenu, + furi_string_get_cstr(label), + idx++, + nfc_scene_mf_desfire_data_submenu_callback, + nfc); } + furi_string_free(label); if(state >= MifareDesfireDataStateItem) { submenu_set_selected_item( diff --git a/applications/services/gui/modules/submenu.c b/applications/services/gui/modules/submenu.c index f8af44fdb..72626c587 100644 --- a/applications/services/gui/modules/submenu.c +++ b/applications/services/gui/modules/submenu.c @@ -9,17 +9,48 @@ struct Submenu { }; typedef struct { - const char* label; + FuriString* label; uint32_t index; SubmenuItemCallback callback; void* callback_context; } SubmenuItem; -ARRAY_DEF(SubmenuItemArray, SubmenuItem, M_POD_OPLIST); +static void SubmenuItem_init(SubmenuItem* item) { + item->label = furi_string_alloc(); + item->index = 0; + item->callback = NULL; + item->callback_context = NULL; +} + +static void SubmenuItem_init_set(SubmenuItem* item, const SubmenuItem* src) { + item->label = furi_string_alloc_set(src->label); + item->index = src->index; + item->callback = src->callback; + item->callback_context = src->callback_context; +} + +static void SubmenuItem_set(SubmenuItem* item, const SubmenuItem* src) { + furi_string_set(item->label, src->label); + item->index = src->index; + item->callback = src->callback; + item->callback_context = src->callback_context; +} + +static void SubmenuItem_clear(SubmenuItem* item) { + furi_string_free(item->label); +} + +ARRAY_DEF( + SubmenuItemArray, + SubmenuItem, + (INIT(API_2(SubmenuItem_init)), + SET(API_6(SubmenuItem_set)), + INIT_SET(API_6(SubmenuItem_init_set)), + CLEAR(API_2(SubmenuItem_clear)))) typedef struct { SubmenuItemArray_t items; - const char* header; + FuriString* header; size_t position; size_t window_position; } SubmenuModel; @@ -36,9 +67,9 @@ static void submenu_view_draw_callback(Canvas* canvas, void* _model) { canvas_clear(canvas); - if(model->header) { + if(!furi_string_empty(model->header)) { canvas_set_font(canvas, FontPrimary); - canvas_draw_str(canvas, 4, 11, model->header); + canvas_draw_str(canvas, 4, 11, furi_string_get_cstr(model->header)); } canvas_set_font(canvas, FontSecondary); @@ -48,8 +79,8 @@ static void submenu_view_draw_callback(Canvas* canvas, void* _model) { for(SubmenuItemArray_it(it, model->items); !SubmenuItemArray_end_p(it); SubmenuItemArray_next(it)) { const size_t item_position = position - model->window_position; - const size_t items_on_screen = model->header ? 3 : 4; - uint8_t y_offset = model->header ? 16 : 0; + const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3; + uint8_t y_offset = furi_string_empty(model->header) ? 0 : 16; if(item_position < items_on_screen) { if(position == model->position) { @@ -134,7 +165,7 @@ Submenu* submenu_alloc() { SubmenuItemArray_init(model->items); model->position = 0; model->window_position = 0; - model->header = NULL; + model->header = furi_string_alloc(); }, true); @@ -145,7 +176,13 @@ void submenu_free(Submenu* submenu) { furi_assert(submenu); with_view_model( - submenu->view, SubmenuModel * model, { SubmenuItemArray_clear(model->items); }, true); + submenu->view, + SubmenuModel * model, + { + furi_string_free(model->header); + SubmenuItemArray_clear(model->items); + }, + true); view_free(submenu->view); free(submenu); } @@ -170,7 +207,7 @@ void submenu_add_item( SubmenuModel * model, { item = SubmenuItemArray_push_new(model->items); - item->label = label; + furi_string_set_str(item->label, label); item->index = index; item->callback = callback; item->callback_context = callback_context; @@ -188,7 +225,7 @@ void submenu_reset(Submenu* submenu) { SubmenuItemArray_reset(model->items); model->position = 0; model->window_position = 0; - model->header = NULL; + furi_string_reset(model->header); }, true); } @@ -221,7 +258,7 @@ void submenu_set_selected_item(Submenu* submenu, uint32_t index) { model->window_position -= 1; } - const size_t items_on_screen = model->header ? 3 : 4; + const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3; if(items_size <= items_on_screen) { model->window_position = 0; @@ -240,7 +277,7 @@ void submenu_process_up(Submenu* submenu) { submenu->view, SubmenuModel * model, { - const size_t items_on_screen = model->header ? 3 : 4; + const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3; const size_t items_size = SubmenuItemArray_size(model->items); if(model->position > 0) { @@ -263,7 +300,7 @@ void submenu_process_down(Submenu* submenu) { submenu->view, SubmenuModel * model, { - const size_t items_on_screen = model->header ? 3 : 4; + const size_t items_on_screen = furi_string_empty(model->header) ? 4 : 3; const size_t items_size = SubmenuItemArray_size(model->items); if(model->position < items_size - 1) { @@ -303,5 +340,14 @@ void submenu_set_header(Submenu* submenu, const char* header) { furi_assert(submenu); with_view_model( - submenu->view, SubmenuModel * model, { model->header = header; }, true); + submenu->view, + SubmenuModel * model, + { + if(header == NULL) { + furi_string_reset(model->header); + } else { + furi_string_set_str(model->header, header); + } + }, + true); }