mount/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GUI: rename widget to ViewPort. Update GUI API usage. (#317)

Browse Source
This commit is contained in:
あく 2021-01-29 16:52:16 +03:00 committed by GitHub
parent 7243758b40
commit 523f99f154
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 400 additions and 404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
applications/app-loader/app-loader.c
View File

@ -10,7 +10,7 @@
typedef struct { typedef struct {
osThreadAttr_t app_thread_attr; osThreadAttr_t app_thread_attr;
osThreadId_t app_thread_id; osThreadId_t app_thread_id;
Widget* widget; ViewPort* view_port;
const FuriApplication* current_app; const FuriApplication* current_app;
} AppLoaderState; } AppLoaderState;
@ -38,7 +38,7 @@ static void input_callback(InputEvent* input_event, void* _ctx) {
if(input_event->state && input_event->input == InputBack) { if(input_event->state && input_event->input == InputBack) {
osThreadTerminate(ctx->app_thread_id); osThreadTerminate(ctx->app_thread_id);
widget_enabled_set(ctx->widget, false); view_port_enabled_set(ctx->view_port, false);
api_hal_timebase_insomnia_exit(); api_hal_timebase_insomnia_exit();
} }
} }
@ -48,7 +48,7 @@ static void handle_menu(void* _ctx) {
if(ctx->app->app == NULL) return; if(ctx->app->app == NULL) return;
widget_enabled_set(ctx->state->widget, true); view_port_enabled_set(ctx->state->view_port, true);
// TODO how to call this? // TODO how to call this?
// furiac_wait_libs(&FLIPPER_STARTUP[i].libs); // furiac_wait_libs(&FLIPPER_STARTUP[i].libs);
@ -100,16 +100,16 @@ void app_loader(void* p) {
AppLoaderState state; AppLoaderState state;
state.app_thread_id = NULL; state.app_thread_id = NULL;
state.widget = widget_alloc(); state.view_port = view_port_alloc();
widget_enabled_set(state.widget, false); view_port_enabled_set(state.view_port, false);
widget_draw_callback_set(state.widget, render_callback, &state); view_port_draw_callback_set(state.view_port, render_callback, &state);
widget_input_callback_set(state.widget, input_callback, &state); view_port_input_callback_set(state.view_port, input_callback, &state);
ValueMutex* menu_mutex = furi_record_open("menu"); ValueMutex* menu_mutex = furi_record_open("menu");
Cli* cli = furi_record_open("cli"); Cli* cli = furi_record_open("cli");
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, state.widget, GuiLayerFullscreen); gui_add_view_port(gui, state.view_port, GuiLayerFullscreen);
// Main menu // Main menu
with_value_mutex( with_value_mutex(

10
applications/applications.c
View File

@ -6,8 +6,6 @@ void flipper_test_app(void* p);
void application_blink(void* p); void application_blink(void* p);
void application_uart_write(void* p); void application_uart_write(void* p);
void application_ipc_display(void* p);
void application_ipc_widget(void* p);
void application_input_dump(void* p); void application_input_dump(void* p);
void display_u8g2(void* p); void display_u8g2(void* p);
void u8g2_example(void* p); void u8g2_example(void* p);
@ -112,14 +110,6 @@ const FuriApplication FLIPPER_SERVICES[] = {
{.app = flipper_test_app, .name = "test app", .stack_size = 1024, .icon = A_Plugins_14}, {.app = flipper_test_app, .name = "test app", .stack_size = 1024, .icon = A_Plugins_14},
#endif #endif
#ifdef APP_EXAMPLE_IPC
{.app = application_ipc_display,
.name = "ipc display",
.stack_size = 1024,
.icon = A_Plugins_14},
{.app = application_ipc_widget, .name = "ipc widget", .stack_size = 1024, .icon = A_Plugins_14},
#endif
#ifdef APP_EXAMPLE_QRCODE #ifdef APP_EXAMPLE_QRCODE
{.app = u8g2_qrcode, .name = "u8g2_qrcode", .stack_size = 1024, .icon = A_Plugins_14}, {.app = u8g2_qrcode, .name = "u8g2_qrcode", .stack_size = 1024, .icon = A_Plugins_14},
#endif #endif

12
applications/bt/bt.c
View File

@ -9,11 +9,11 @@ Bt* bt_alloc() {
bt->menu = furi_record_open("menu"); bt->menu = furi_record_open("menu");
bt->statusbar_icon = assets_icons_get(I_Bluetooth_5x8); bt->statusbar_icon = assets_icons_get(I_Bluetooth_5x8);
bt->statusbar_widget = widget_alloc(); bt->statusbar_view_port = view_port_alloc();
widget_set_width(bt->statusbar_widget, icon_get_width(bt->statusbar_icon)); view_port_set_width(bt->statusbar_view_port, icon_get_width(bt->statusbar_icon));
widget_draw_callback_set(bt->statusbar_widget, bt_draw_statusbar_callback, bt); view_port_draw_callback_set(bt->statusbar_view_port, bt_draw_statusbar_callback, bt);
widget_enabled_set(bt->statusbar_widget, false); view_port_enabled_set(bt->statusbar_view_port, false);
gui_add_widget(bt->gui, bt->statusbar_widget, GuiLayerStatusBarLeft); gui_add_view_port(bt->gui, bt->statusbar_view_port, GuiLayerStatusBarLeft);
bt->menu_icon = assets_icons_get(A_Bluetooth_14); bt->menu_icon = assets_icons_get(A_Bluetooth_14);
bt->menu_item = menu_item_alloc_menu("Bluetooth", bt->menu_icon); bt->menu_item = menu_item_alloc_menu("Bluetooth", bt->menu_icon);
@ -45,7 +45,7 @@ void bt_task() {
api_hal_bt_init(); api_hal_bt_init();
while(1) { while(1) {
widget_enabled_set(bt->statusbar_widget, api_hal_bt_is_alive()); view_port_enabled_set(bt->statusbar_view_port, api_hal_bt_is_alive());
osDelay(1000); osDelay(1000);
} }
} }

4
applications/bt/bt_i.h
View File

@ -7,7 +7,7 @@
#include <cli/cli.h> #include <cli/cli.h>
#include <gui/gui.h> #include <gui/gui.h>
#include <gui/widget.h> #include <gui/view_port.h>
#include <menu/menu.h> #include <menu/menu.h>
#include <menu/menu_item.h> #include <menu/menu_item.h>
@ -18,7 +18,7 @@ typedef struct {
ValueMutex* menu; ValueMutex* menu;
// Status bar // Status bar
Icon* statusbar_icon; Icon* statusbar_icon;
Widget* statusbar_widget; ViewPort* statusbar_view_port;
// Menu // Menu
Icon* menu_icon; Icon* menu_icon;
MenuItem* menu_item; MenuItem* menu_item;

16
applications/cc1101-workaround/cc1101-workaround.cpp
View File

@ -363,18 +363,18 @@ extern "C" void cc1101_workaround(void* p) {
furiac_exit(NULL); furiac_exit(NULL);
} }
Widget* widget = widget_alloc(); ViewPort* view_port = view_port_alloc();
widget_draw_callback_set(widget, render_callback, &state_mutex); view_port_draw_callback_set(view_port, render_callback, &state_mutex);
widget_input_callback_set(widget, input_callback, event_queue); view_port_input_callback_set(view_port, input_callback, event_queue);
// Open GUI and register widget // Open GUI and register view_port
Gui* gui = (Gui*)furi_record_open("gui"); Gui* gui = (Gui*)furi_record_open("gui");
if(gui == NULL) { if(gui == NULL) {
printf("[cc1101] gui is not available\r\n"); printf("[cc1101] gui is not available\r\n");
furiac_exit(NULL); furiac_exit(NULL);
} }
gui_add_widget(gui, widget, GuiLayerFullscreen); gui_add_view_port(gui, view_port, GuiLayerFullscreen);
gpio_init(&debug_0, GpioModeOutputPushPull); gpio_init(&debug_0, GpioModeOutputPushPull);
gpio_write((GpioPin*)&debug_0, false); gpio_write((GpioPin*)&debug_0, false);
@ -433,8 +433,8 @@ extern "C" void cc1101_workaround(void* p) {
printf("[cc1101] go to power down\r\n"); printf("[cc1101] go to power down\r\n");
// TODO remove all widgets create by app // TODO remove all view_ports create by app
widget_enabled_set(widget, false); view_port_enabled_set(view_port, false);
furiac_exit(NULL); furiac_exit(NULL);
} }
@ -582,6 +582,6 @@ extern "C" void cc1101_workaround(void* p) {
} }
release_mutex(&state_mutex, state); release_mutex(&state_mutex, state);
widget_update(widget); view_port_update(view_port);
} }
} }

2
applications/examples/u8g2_qrcode.c
View File

@ -37,7 +37,7 @@ void u8g2_qrcode(void* p) {
qrcode_initText(&qrcode, qrcodeBytes, qr_version, qr_error_correction, "HELLO FLIPPER"); qrcode_initText(&qrcode, qrcodeBytes, qr_version, qr_error_correction, "HELLO FLIPPER");
if(fb_record == NULL) { if(fb_record == NULL) {
printf("[widget] cannot create fb record\r\n"); printf("[view_port] cannot create fb record\r\n");
furiac_exit(NULL); furiac_exit(NULL);
} }

2
applications/floopper-bloopper

@ -1 +1 @@
Subproject commit 7ba50ef912566c78d2ddd37ab5912a8cada5c35d Subproject commit 2d66001e894d80995125fffc2e8ed17a970ee428

16
applications/gpio-tester/gpio-tester.c
View File

@ -70,14 +70,14 @@ void app_gpio_test(void* p) {
furiac_exit(NULL); furiac_exit(NULL);
} }
Widget* widget = widget_alloc(); ViewPort* view_port = view_port_alloc();
widget_draw_callback_set(widget, render_callback, &state_mutex); view_port_draw_callback_set(view_port, render_callback, &state_mutex);
widget_input_callback_set(widget, input_callback, event_queue); view_port_input_callback_set(view_port, input_callback, event_queue);
// Open GUI and register widget // Open GUI and register view_port
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, widget, GuiLayerFullscreen); gui_add_view_port(gui, view_port, GuiLayerFullscreen);
// configure pin // configure pin
for(uint8_t i = 0; i < sizeof(GPIO_PINS) / sizeof(GPIO_PINS[0]); i++) { for(uint8_t i = 0; i < sizeof(GPIO_PINS) / sizeof(GPIO_PINS[0]); i++) {
@ -95,8 +95,8 @@ void app_gpio_test(void* p) {
if(event.type == EventTypeKey) { if(event.type == EventTypeKey) {
if(event.value.input.state && event.value.input.input == InputBack) { if(event.value.input.state && event.value.input.input == InputBack) {
printf("[gpio-tester] bye!\r\n"); printf("[gpio-tester] bye!\r\n");
// TODO remove all widgets create by app // TODO remove all view_ports create by app
widget_enabled_set(widget, false); view_port_enabled_set(view_port, false);
furiac_exit(NULL); furiac_exit(NULL);
} }
@ -121,6 +121,6 @@ void app_gpio_test(void* p) {
} }
release_mutex(&state_mutex, state); release_mutex(&state_mutex, state);
widget_update(widget); view_port_update(view_port);
} }
} }

112
applications/gui/gui.c
View File

@ -8,24 +8,24 @@
#include "gui_event.h" #include "gui_event.h"
#include "canvas.h" #include "canvas.h"
#include "canvas_i.h" #include "canvas_i.h"
#include "widget.h" #include "view_port.h"
#include "widget_i.h" #include "view_port_i.h"
ARRAY_DEF(WidgetArray, Widget*, M_PTR_OPLIST); ARRAY_DEF(ViewPortArray, ViewPort*, M_PTR_OPLIST);
struct Gui { struct Gui {
GuiEvent* event; GuiEvent* event;
Canvas* canvas; Canvas* canvas;
WidgetArray_t layers[GuiLayerMAX]; ViewPortArray_t layers[GuiLayerMAX];
osMutexId_t mutex; osMutexId_t mutex;
}; };
Widget* gui_widget_find_enabled(WidgetArray_t array) { ViewPort* gui_view_port_find_enabled(ViewPortArray_t array) {
size_t widgets_count = WidgetArray_size(array); size_t view_ports_count = ViewPortArray_size(array);
for(size_t i = 0; i < widgets_count; i++) { for(size_t i = 0; i < view_ports_count; i++) {
Widget* widget = *WidgetArray_get(array, widgets_count - i - 1); ViewPort* view_port = *ViewPortArray_get(array, view_ports_count - i - 1);
if(widget_is_enabled(widget)) { if(view_port_is_enabled(view_port)) {
return widget; return view_port;
} }
} }
return NULL; return NULL;
@ -40,9 +40,9 @@ void gui_update(Gui* gui) {
bool gui_redraw_fs(Gui* gui) { bool gui_redraw_fs(Gui* gui) {
canvas_frame_set(gui->canvas, 0, 0, GUI_DISPLAY_WIDTH, GUI_DISPLAY_HEIGHT); canvas_frame_set(gui->canvas, 0, 0, GUI_DISPLAY_WIDTH, GUI_DISPLAY_HEIGHT);
Widget* widget = gui_widget_find_enabled(gui->layers[GuiLayerFullscreen]); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]);
if(widget) { if(view_port) {
widget_draw(widget, gui->canvas); view_port_draw(view_port, gui->canvas);
return true; return true;
} else { } else {
return false; return false;
@ -50,50 +50,50 @@ bool gui_redraw_fs(Gui* gui) {
} }
void gui_redraw_status_bar(Gui* gui) { void gui_redraw_status_bar(Gui* gui) {
WidgetArray_it_t it; ViewPortArray_it_t it;
uint8_t x; uint8_t x;
uint8_t x_used = 0; uint8_t x_used = 0;
uint8_t width; uint8_t width;
Widget* widget; ViewPort* view_port;
// Right side // Right side
x = 128; x = 128;
WidgetArray_it(it, gui->layers[GuiLayerStatusBarRight]); ViewPortArray_it(it, gui->layers[GuiLayerStatusBarRight]);
while(!WidgetArray_end_p(it) && x_used < GUI_STATUS_BAR_WIDTH) { while(!ViewPortArray_end_p(it) && x_used < GUI_STATUS_BAR_WIDTH) {
// Render widget; // Render view_port;
widget = *WidgetArray_ref(it); view_port = *ViewPortArray_ref(it);
if(widget_is_enabled(widget)) { if(view_port_is_enabled(view_port)) {
width = widget_get_width(widget); width = view_port_get_width(view_port);
if(!width) width = 8; if(!width) width = 8;
x_used += width; x_used += width;
x -= (width + 2); x -= (width + 2);
canvas_frame_set(gui->canvas, x, GUI_STATUS_BAR_Y, width, GUI_STATUS_BAR_HEIGHT); canvas_frame_set(gui->canvas, x, GUI_STATUS_BAR_Y, width, GUI_STATUS_BAR_HEIGHT);
widget_draw(widget, gui->canvas); view_port_draw(view_port, gui->canvas);
} }
WidgetArray_next(it); ViewPortArray_next(it);
} }
// Left side // Left side
x = 0; x = 0;
WidgetArray_it(it, gui->layers[GuiLayerStatusBarLeft]); ViewPortArray_it(it, gui->layers[GuiLayerStatusBarLeft]);
while(!WidgetArray_end_p(it) && x_used < GUI_STATUS_BAR_WIDTH) { while(!ViewPortArray_end_p(it) && x_used < GUI_STATUS_BAR_WIDTH) {
// Render widget; // Render view_port;
widget = *WidgetArray_ref(it); view_port = *ViewPortArray_ref(it);
if(widget_is_enabled(widget)) { if(view_port_is_enabled(view_port)) {
width = widget_get_width(widget); width = view_port_get_width(view_port);
if(!width) width = 8; if(!width) width = 8;
x_used += width; x_used += width;
canvas_frame_set(gui->canvas, x, GUI_STATUS_BAR_Y, width, GUI_STATUS_BAR_HEIGHT); canvas_frame_set(gui->canvas, x, GUI_STATUS_BAR_Y, width, GUI_STATUS_BAR_HEIGHT);
widget_draw(widget, gui->canvas); view_port_draw(view_port, gui->canvas);
x += (width + 2); x += (width + 2);
} }
WidgetArray_next(it); ViewPortArray_next(it);
} }
} }
bool gui_redraw_normal(Gui* gui) { bool gui_redraw_normal(Gui* gui) {
canvas_frame_set(gui->canvas, GUI_MAIN_X, GUI_MAIN_Y, GUI_MAIN_WIDTH, GUI_MAIN_HEIGHT); canvas_frame_set(gui->canvas, GUI_MAIN_X, GUI_MAIN_Y, GUI_MAIN_WIDTH, GUI_MAIN_HEIGHT);
Widget* widget = gui_widget_find_enabled(gui->layers[GuiLayerMain]); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerMain]);
if(widget) { if(view_port) {
widget_draw(widget, gui->canvas); view_port_draw(view_port, gui->canvas);
return true; return true;
} }
return false; return false;
@ -101,9 +101,9 @@ bool gui_redraw_normal(Gui* gui) {
bool gui_redraw_none(Gui* gui) { bool gui_redraw_none(Gui* gui) {
canvas_frame_set(gui->canvas, GUI_MAIN_X, GUI_MAIN_Y, GUI_MAIN_WIDTH, GUI_MAIN_HEIGHT); canvas_frame_set(gui->canvas, GUI_MAIN_X, GUI_MAIN_Y, GUI_MAIN_WIDTH, GUI_MAIN_HEIGHT);
Widget* widget = gui_widget_find_enabled(gui->layers[GuiLayerNone]); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerNone]);
if(widget) { if(view_port) {
widget_draw(widget, gui->canvas); view_port_draw(view_port, gui->canvas);
return true; return true;
} }
@ -133,12 +133,12 @@ void gui_input(Gui* gui, InputEvent* input_event) {
gui_lock(gui); gui_lock(gui);
Widget* widget = gui_widget_find_enabled(gui->layers[GuiLayerFullscreen]); ViewPort* view_port = gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]);
if(!widget) widget = gui_widget_find_enabled(gui->layers[GuiLayerMain]); if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerMain]);
if(!widget) widget = gui_widget_find_enabled(gui->layers[GuiLayerNone]); if(!view_port) view_port = gui_view_port_find_enabled(gui->layers[GuiLayerNone]);
if(widget) { if(view_port) {
widget_input(widget, input_event); view_port_input(view_port, input_event);
} }
gui_unlock(gui); gui_unlock(gui);
@ -154,33 +154,33 @@ void gui_unlock(Gui* gui) {
furi_check(osMutexRelease(gui->mutex) == osOK); furi_check(osMutexRelease(gui->mutex) == osOK);
} }
void gui_add_widget(Gui* gui, Widget* widget, GuiLayer layer) { void gui_add_view_port(Gui* gui, ViewPort* view_port, GuiLayer layer) {
furi_assert(gui); furi_assert(gui);
furi_assert(widget); furi_assert(view_port);
furi_check(layer < GuiLayerMAX); furi_check(layer < GuiLayerMAX);
gui_lock(gui); gui_lock(gui);
WidgetArray_push_back(gui->layers[layer], widget); ViewPortArray_push_back(gui->layers[layer], view_port);
widget_gui_set(widget, gui); view_port_gui_set(view_port, gui);
gui_unlock(gui); gui_unlock(gui);
gui_update(gui); gui_update(gui);
} }
void gui_remove_widget(Gui* gui, Widget* widget) { void gui_remove_view_port(Gui* gui, ViewPort* view_port) {
furi_assert(gui); furi_assert(gui);
furi_assert(widget); furi_assert(view_port);
gui_lock(gui); gui_lock(gui);
widget_gui_set(widget, NULL); view_port_gui_set(view_port, NULL);
WidgetArray_it_t it; ViewPortArray_it_t it;
for(size_t i = 0; i < GuiLayerMAX; i++) { for(size_t i = 0; i < GuiLayerMAX; i++) {
WidgetArray_it(it, gui->layers[i]); ViewPortArray_it(it, gui->layers[i]);
while(!WidgetArray_end_p(it)) { while(!ViewPortArray_end_p(it)) {
if(*WidgetArray_ref(it) == widget) { if(*ViewPortArray_ref(it) == view_port) {
WidgetArray_remove(gui->layers[i], it); ViewPortArray_remove(gui->layers[i], it);
} }
WidgetArray_next(it); ViewPortArray_next(it);
} }
} }
@ -198,7 +198,7 @@ Gui* gui_alloc() {
gui->canvas = canvas_init(); gui->canvas = canvas_init();
// Compose Layers // Compose Layers
for(size_t i = 0; i < GuiLayerMAX; i++) { for(size_t i = 0; i < GuiLayerMAX; i++) {
WidgetArray_init(gui->layers[i]); ViewPortArray_init(gui->layers[i]);
} }
return gui; return gui;

18
applications/gui/gui.h
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "widget.h" #include "view_port.h"
#include "canvas.h" #include "canvas.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -23,10 +23,10 @@ extern "C" {
typedef enum { typedef enum {
GuiLayerNone, /* Special layer for internal use only */ GuiLayerNone, /* Special layer for internal use only */
GuiLayerStatusBarLeft, /* Status bar left-side widget layer, auto-layout */ GuiLayerStatusBarLeft, /* Status bar left-side view_port layer, auto-layout */
GuiLayerStatusBarRight, /* Status bar right-side widget layer, auto-layout */ GuiLayerStatusBarRight, /* Status bar right-side view_port layer, auto-layout */
GuiLayerMain, /* Main widget layer, status bar is shown */ GuiLayerMain, /* Main view_port layer, status bar is shown */
GuiLayerFullscreen, /* Fullscreen widget layer */ GuiLayerFullscreen, /* Fullscreen view_port layer */
GuiLayerMAX /* Don't use or move, special value */ GuiLayerMAX /* Don't use or move, special value */
} GuiLayer; } GuiLayer;
@ -34,16 +34,16 @@ typedef enum {
typedef struct Gui Gui; typedef struct Gui Gui;
/* /*
* Add widget to widget tree * Add view_port to view_port tree
* @remarks thread safe * @remarks thread safe
*/ */
void gui_add_widget(Gui* gui, Widget* widget, GuiLayer layer); void gui_add_view_port(Gui* gui, ViewPort* view_port, GuiLayer layer);
/* /*
* Remove widget from rendering tree * Remove view_port from rendering tree
* @remarks thread safe * @remarks thread safe
*/ */
void gui_remove_widget(Gui* gui, Widget* widget); void gui_remove_view_port(Gui* gui, ViewPort* view_port);
#ifdef __cplusplus #ifdef __cplusplus
} }

2
applications/gui/view.h
View File

@ -7,7 +7,7 @@
extern "C" { extern "C" {
#endif #endif
/* Hides drawing widget */ /* Hides drawing view_port */
#define VIEW_NONE 0xFFFFFFFF #define VIEW_NONE 0xFFFFFFFF
/* Ignore navigation event */ /* Ignore navigation event */
#define VIEW_IGNORE 0xFFFFFFFE #define VIEW_IGNORE 0xFFFFFFFE

28
applications/gui/view_dispatcher.c
View File

@ -3,12 +3,12 @@
ViewDispatcher* view_dispatcher_alloc() { ViewDispatcher* view_dispatcher_alloc() {
ViewDispatcher* view_dispatcher = furi_alloc(sizeof(ViewDispatcher)); ViewDispatcher* view_dispatcher = furi_alloc(sizeof(ViewDispatcher));
view_dispatcher->widget = widget_alloc(); view_dispatcher->view_port = view_port_alloc();
widget_draw_callback_set( view_port_draw_callback_set(
view_dispatcher->widget, view_dispatcher_draw_callback, view_dispatcher); view_dispatcher->view_port, view_dispatcher_draw_callback, view_dispatcher);
widget_input_callback_set( view_port_input_callback_set(
view_dispatcher->widget, view_dispatcher_input_callback, view_dispatcher); view_dispatcher->view_port, view_dispatcher_input_callback, view_dispatcher);
widget_enabled_set(view_dispatcher->widget, false); view_port_enabled_set(view_dispatcher->view_port, false);
ViewDict_init(view_dispatcher->views); ViewDict_init(view_dispatcher->views);
@ -18,7 +18,7 @@ ViewDispatcher* view_dispatcher_alloc() {
void view_dispatcher_free(ViewDispatcher* view_dispatcher) { void view_dispatcher_free(ViewDispatcher* view_dispatcher) {
// Detach from gui // Detach from gui
if(view_dispatcher->gui) { if(view_dispatcher->gui) {
gui_remove_widget(view_dispatcher->gui, view_dispatcher->widget); gui_remove_view_port(view_dispatcher->gui, view_dispatcher->view_port);
} }
// Free views // Free views
ViewDict_it_t it; ViewDict_it_t it;
@ -46,7 +46,7 @@ void view_dispatcher_switch_to_view(ViewDispatcher* view_dispatcher, uint32_t vi
furi_assert(view_dispatcher); furi_assert(view_dispatcher);
if(view_id == VIEW_NONE) { if(view_id == VIEW_NONE) {
view_dispatcher->current_view = NULL; view_dispatcher->current_view = NULL;
widget_enabled_set(view_dispatcher->widget, false); view_port_enabled_set(view_dispatcher->view_port, false);
} else if(view_id == VIEW_IGNORE) { } else if(view_id == VIEW_IGNORE) {
} else if(view_id == VIEW_DESTROY) { } else if(view_id == VIEW_DESTROY) {
view_dispatcher_free(view_dispatcher); view_dispatcher_free(view_dispatcher);
@ -54,8 +54,8 @@ void view_dispatcher_switch_to_view(ViewDispatcher* view_dispatcher, uint32_t vi
View** view_pp = ViewDict_get(view_dispatcher->views, view_id); View** view_pp = ViewDict_get(view_dispatcher->views, view_id);
furi_check(view_pp != NULL); furi_check(view_pp != NULL);
view_dispatcher->current_view = *view_pp; view_dispatcher->current_view = *view_pp;
widget_enabled_set(view_dispatcher->widget, true); view_port_enabled_set(view_dispatcher->view_port, true);
widget_update(view_dispatcher->widget); view_port_update(view_dispatcher->view_port);
} }
} }
@ -68,11 +68,11 @@ void view_dispatcher_attach_to_gui(
furi_assert(gui); furi_assert(gui);
if(type == ViewDispatcherTypeNone) { if(type == ViewDispatcherTypeNone) {
gui_add_widget(gui, view_dispatcher->widget, GuiLayerNone); gui_add_view_port(gui, view_dispatcher->view_port, GuiLayerNone);
} else if(type == ViewDispatcherTypeFullscreen) { } else if(type == ViewDispatcherTypeFullscreen) {
gui_add_widget(gui, view_dispatcher->widget, GuiLayerFullscreen); gui_add_view_port(gui, view_dispatcher->view_port, GuiLayerFullscreen);
} else if(type == ViewDispatcherTypeWindow) { } else if(type == ViewDispatcherTypeWindow) {
gui_add_widget(gui, view_dispatcher->widget, GuiLayerMain); gui_add_view_port(gui, view_dispatcher->view_port, GuiLayerMain);
} else { } else {
furi_check(NULL); furi_check(NULL);
} }
@ -108,6 +108,6 @@ void view_dispatcher_update(ViewDispatcher* view_dispatcher, View* view) {
furi_assert(view); furi_assert(view);
if(view_dispatcher->current_view == view) { if(view_dispatcher->current_view == view) {
widget_update(view_dispatcher->widget); view_port_update(view_dispatcher->view_port);
} }
} }

6
applications/gui/view_dispatcher.h
View File

@ -7,11 +7,11 @@
extern "C" { extern "C" {
#endif #endif
/* ViewDispatcher widget placement */ /* ViewDispatcher view_port placement */
typedef enum { typedef enum {
ViewDispatcherTypeNone, /* Special layer for internal use only */ ViewDispatcherTypeNone, /* Special layer for internal use only */
ViewDispatcherTypeWindow, /* Main widget layer, status bar is shown */ ViewDispatcherTypeWindow, /* Main view_port layer, status bar is shown */
ViewDispatcherTypeFullscreen /* Fullscreen widget layer */ ViewDispatcherTypeFullscreen /* Fullscreen view_port layer */
} ViewDispatcherType; } ViewDispatcherType;
typedef struct ViewDispatcher ViewDispatcher; typedef struct ViewDispatcher ViewDispatcher;

6
applications/gui/view_dispatcher_i.h
View File

@ -9,15 +9,15 @@ DICT_DEF2(ViewDict, uint32_t, M_DEFAULT_OPLIST, View*, M_PTR_OPLIST)
struct ViewDispatcher { struct ViewDispatcher {
Gui* gui; Gui* gui;
Widget* widget; ViewPort* view_port;
ViewDict_t views; ViewDict_t views;
View* current_view; View* current_view;
}; };
/* Widget Draw Callback */ /* ViewPort Draw Callback */
void view_dispatcher_draw_callback(Canvas* canvas, void* context); void view_dispatcher_draw_callback(Canvas* canvas, void* context);
/* Widget Input Callback */ /* ViewPort Input Callback */
void view_dispatcher_input_callback(InputEvent* event, void* context); void view_dispatcher_input_callback(InputEvent* event, void* context);
/* View to ViewDispatcher update event */ /* View to ViewDispatcher update event */

98
applications/gui/view_port.c Normal file
View File

@ -0,0 +1,98 @@
#include "view_port_i.h"
#include <furi.h>
#include "gui.h"
#include "gui_i.h"
// TODO add mutex to view_port ops
ViewPort* view_port_alloc(ViewPortDrawCallback callback, void* callback_context) {
ViewPort* view_port = furi_alloc(sizeof(ViewPort));
view_port->is_enabled = true;
return view_port;
}
void view_port_free(ViewPort* view_port) {
furi_assert(view_port);
furi_check(view_port->gui == NULL);
free(view_port);
}
void view_port_set_width(ViewPort* view_port, uint8_t width) {
assert(view_port);
view_port->width = width;
}
uint8_t view_port_get_width(ViewPort* view_port) {
assert(view_port);
return view_port->width;
}
void view_port_set_height(ViewPort* view_port, uint8_t height) {
assert(view_port);
view_port->height = height;
}
uint8_t view_port_get_height(ViewPort* view_port) {
assert(view_port);
return view_port->height;
}
void view_port_enabled_set(ViewPort* view_port, bool enabled) {
furi_assert(view_port);
if(view_port->is_enabled != enabled) {
view_port->is_enabled = enabled;
view_port_update(view_port);
}
}
bool view_port_is_enabled(ViewPort* view_port) {
furi_assert(view_port);
return view_port->is_enabled;
}
void view_port_draw_callback_set(ViewPort* view_port, ViewPortDrawCallback callback, void* context) {
furi_assert(view_port);
view_port->draw_callback = callback;
view_port->draw_callback_context = context;
}
void view_port_input_callback_set(
ViewPort* view_port,
ViewPortInputCallback callback,
void* context) {
furi_assert(view_port);
view_port->input_callback = callback;
view_port->input_callback_context = context;
}
void view_port_update(ViewPort* view_port) {
furi_assert(view_port);
if(view_port->gui) gui_update(view_port->gui);
}
void view_port_gui_set(ViewPort* view_port, Gui* gui) {
furi_assert(view_port);
view_port->gui = gui;
}
void view_port_draw(ViewPort* view_port, Canvas* canvas) {
furi_assert(view_port);
furi_assert(canvas);
furi_check(view_port->gui);
if(view_port->draw_callback) {
view_port->draw_callback(canvas, view_port->draw_callback_context);
}
}
void view_port_input(ViewPort* view_port, InputEvent* event) {
furi_assert(view_port);
furi_assert(event);
furi_check(view_port->gui);
if(view_port->input_callback) {
view_port->input_callback(event, view_port->input_callback_context);
}
}

78
applications/gui/view_port.h Normal file
View File

@ -0,0 +1,78 @@
#pragma once
#include <input/input.h>
#include "canvas.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct ViewPort ViewPort;
/*
* ViewPort Draw callback
* @warning called from GUI thread
*/
typedef void (*ViewPortDrawCallback)(Canvas* canvas, void* context);
/*
* ViewPort Input callback
* @warning called from GUI thread
*/
typedef void (*ViewPortInputCallback)(InputEvent* event, void* context);
/*
* ViewPort allocator
* always returns view_port or stops system if not enough memory.
*/
ViewPort* view_port_alloc();
/*
* ViewPort deallocator
* Ensure that view_port was unregistered in GUI system before use.
*/
void view_port_free(ViewPort* view_port);
/*
* Set view_port width.
* Will be used to limit canvas drawing area and autolayout feature.
* @param width - wanted width, 0 - auto.
*/
void view_port_set_width(ViewPort* view_port, uint8_t width);
uint8_t view_port_get_width(ViewPort* view_port);
/*
* Set view_port height.
* Will be used to limit canvas drawing area and autolayout feature.
* @param height - wanted height, 0 - auto.
*/
void view_port_set_height(ViewPort* view_port, uint8_t height);
uint8_t view_port_get_height(ViewPort* view_port);
/*
* Enable or disable view_port rendering.
* @param enabled.
*/
void view_port_enabled_set(ViewPort* view_port, bool enabled);
bool view_port_is_enabled(ViewPort* view_port);
/*
* ViewPort event callbacks
* @param callback - appropriate callback function
* @param context - context to pass to callback
*/
void view_port_draw_callback_set(ViewPort* view_port, ViewPortDrawCallback callback, void* context);
void view_port_input_callback_set(
ViewPort* view_port,
ViewPortInputCallback callback,
void* context);
/*
* Emit update signal to GUI system.
* Rendering will happen later after GUI system process signal.
*/
void view_port_update(ViewPort* view_port);
#ifdef __cplusplus
}
#endif

16
applications/gui/widget_i.h → applications/gui/view_port_i.h
View File

@ -1,39 +1,39 @@
#pragma once #pragma once
#include "gui_i.h" #include "gui_i.h"
#include "widget.h" #include "view_port.h"
struct Widget { struct ViewPort {
Gui* gui; Gui* gui;
bool is_enabled; bool is_enabled;
uint8_t width; uint8_t width;
uint8_t height; uint8_t height;
WidgetDrawCallback draw_callback; ViewPortDrawCallback draw_callback;
void* draw_callback_context; void* draw_callback_context;
WidgetInputCallback input_callback; ViewPortInputCallback input_callback;
void* input_callback_context; void* input_callback_context;
}; };
/* /*
* Set GUI reference. * Set GUI reference.
* To be used by GUI, called upon widget tree insert * To be used by GUI, called upon view_port tree insert
* @param gui - gui instance pointer. * @param gui - gui instance pointer.
*/ */
void widget_gui_set(Widget* widget, Gui* gui); void view_port_gui_set(ViewPort* view_port, Gui* gui);
/* /*
* Process draw call. Calls draw callback. * Process draw call. Calls draw callback.
* To be used by GUI, called on tree redraw. * To be used by GUI, called on tree redraw.
* @param canvas - canvas to draw at. * @param canvas - canvas to draw at.
*/ */
void widget_draw(Widget* widget, Canvas* canvas); void view_port_draw(ViewPort* view_port, Canvas* canvas);
/* /*
* Process input. Calls input callbac * Process input. Calls input callbac
* To be used by GUI, called on input dispatch. * To be used by GUI, called on input dispatch.
* @param event - pointer to input event. * @param event - pointer to input event.
*/ */
void widget_input(Widget* widget, InputEvent* event); void view_port_input(ViewPort* view_port, InputEvent* event);

95
applications/gui/widget.c
View File

@ -1,95 +0,0 @@
#include "widget_i.h"
#include <furi.h>
#include "gui.h"
#include "gui_i.h"
// TODO add mutex to widget ops
Widget* widget_alloc(WidgetDrawCallback callback, void* callback_context) {
Widget* widget = furi_alloc(sizeof(Widget));
widget->is_enabled = true;
return widget;
}
void widget_free(Widget* widget) {
furi_assert(widget);
furi_check(widget->gui == NULL);
free(widget);
}
void widget_set_width(Widget* widget, uint8_t width) {
assert(widget);
widget->width = width;
}
uint8_t widget_get_width(Widget* widget) {
assert(widget);
return widget->width;
}
void widget_set_height(Widget* widget, uint8_t height) {
assert(widget);
widget->height = height;
}
uint8_t widget_get_height(Widget* widget) {
assert(widget);
return widget->height;
}
void widget_enabled_set(Widget* widget, bool enabled) {
furi_assert(widget);
if(widget->is_enabled != enabled) {
widget->is_enabled = enabled;
widget_update(widget);
}
}
bool widget_is_enabled(Widget* widget) {
furi_assert(widget);
return widget->is_enabled;
}
void widget_draw_callback_set(Widget* widget, WidgetDrawCallback callback, void* context) {
furi_assert(widget);
widget->draw_callback = callback;
widget->draw_callback_context = context;
}
void widget_input_callback_set(Widget* widget, WidgetInputCallback callback, void* context) {
furi_assert(widget);
widget->input_callback = callback;
widget->input_callback_context = context;
}
void widget_update(Widget* widget) {
furi_assert(widget);
if(widget->gui) gui_update(widget->gui);
}
void widget_gui_set(Widget* widget, Gui* gui) {
furi_assert(widget);
widget->gui = gui;
}
void widget_draw(Widget* widget, Canvas* canvas) {
furi_assert(widget);
furi_assert(canvas);
furi_check(widget->gui);
if(widget->draw_callback) {
widget->draw_callback(canvas, widget->draw_callback_context);
}
}
void widget_input(Widget* widget, InputEvent* event) {
furi_assert(widget);
furi_assert(event);
furi_check(widget->gui);
if(widget->input_callback) {
widget->input_callback(event, widget->input_callback_context);
}
}

75
applications/gui/widget.h
View File

@ -1,75 +0,0 @@
#pragma once
#include <input/input.h>
#include "canvas.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct Widget Widget;
/*
* Widget Draw callback
* @warning called from GUI thread
*/
typedef void (*WidgetDrawCallback)(Canvas* canvas, void* context);
/*
* Widget Input callback
* @warning called from GUI thread
*/
typedef void (*WidgetInputCallback)(InputEvent* event, void* context);
/*
* Widget allocator
* always returns widget or stops system if not enough memory.
*/
Widget* widget_alloc();
/*
* Widget deallocator
* Ensure that widget was unregistered in GUI system before use.
*/
void widget_free(Widget* widget);
/*
* Set widget width.
* Will be used to limit canvas drawing area and autolayout feature.
* @param width - wanted width, 0 - auto.
*/
void widget_set_width(Widget* widget, uint8_t width);
uint8_t widget_get_width(Widget* widget);
/*
* Set widget height.
* Will be used to limit canvas drawing area and autolayout feature.
* @param height - wanted height, 0 - auto.
*/
void widget_set_height(Widget* widget, uint8_t height);
uint8_t widget_get_height(Widget* widget);
/*
* Enable or disable widget rendering.
* @param enabled.
*/
void widget_enabled_set(Widget* widget, bool enabled);
bool widget_is_enabled(Widget* widget);
/*
* Widget event callbacks
* @param callback - appropriate callback function
* @param context - context to pass to callback
*/
void widget_draw_callback_set(Widget* widget, WidgetDrawCallback callback, void* context);
void widget_input_callback_set(Widget* widget, WidgetInputCallback callback, void* context);
/*
* Emit update signal to GUI system.
* Rendering will happen later after GUI system process signal.
*/
void widget_update(Widget* widget);
#ifdef __cplusplus
}
#endif

6
applications/ibutton/ibutton.cpp
View File

@ -32,8 +32,8 @@ void AppiButton::run() {
if(event.type == AppiButtonEvent::EventTypeKey) { if(event.type == AppiButtonEvent::EventTypeKey) {
// press events // press events
if(event.value.input.state && event.value.input.input == InputBack) { if(event.value.input.state && event.value.input.input == InputBack) {
widget_enabled_set(widget, false); view_port_enabled_set(view_port, false);
gui_remove_widget(gui, widget); gui_remove_view_port(gui, view_port);
api_hal_timebase_insomnia_exit(); api_hal_timebase_insomnia_exit();
osThreadExit(); osThreadExit();
@ -55,7 +55,7 @@ void AppiButton::run() {
mode[state.mode_index]->event(&event, &state); mode[state.mode_index]->event(&event, &state);
release_state(); release_state();
widget_update(widget); view_port_update(view_port);
}; };
} }

18
applications/irda/irda.c
View File

@ -267,14 +267,14 @@ void irda(void* p) {
furiac_exit(NULL); furiac_exit(NULL);
} }
Widget* widget = widget_alloc(); ViewPort* view_port = view_port_alloc();
widget_draw_callback_set(widget, render_callback, &state_mutex); view_port_draw_callback_set(view_port, render_callback, &state_mutex);
widget_input_callback_set(widget, input_callback, event_queue); view_port_input_callback_set(view_port, input_callback, event_queue);
// Open GUI and register widget // Open GUI and register view_port
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, widget, GuiLayerFullscreen); gui_add_view_port(gui, view_port, GuiLayerFullscreen);
// Red LED // Red LED
// TODO open record // TODO open record
@ -302,9 +302,9 @@ void irda(void* p) {
if(event.type == EventTypeKey) { if(event.type == EventTypeKey) {
// press events // press events
if(event.value.input.state && event.value.input.input == InputBack) { if(event.value.input.state && event.value.input.input == InputBack) {
// remove all widgets create by app // remove all view_ports create by app
widget_enabled_set(widget, false); view_port_enabled_set(view_port, false);
gui_remove_widget(gui, widget); gui_remove_view_port(gui, view_port);
// free decoder // free decoder
free_decoder(decoder); free_decoder(decoder);
@ -372,6 +372,6 @@ void irda(void* p) {
} }
release_mutex(&state_mutex, state); release_mutex(&state_mutex, state);
widget_update(widget); view_port_update(view_port);
} }
} }

16
applications/lf-rfid/lf-rfid.c
View File

@ -198,14 +198,14 @@ void lf_rfid_workaround(void* p) {
furiac_exit(NULL); furiac_exit(NULL);
} }
Widget* widget = widget_alloc(); ViewPort* view_port = view_port_alloc();
widget_draw_callback_set(widget, render_callback, &state_mutex); view_port_draw_callback_set(view_port, render_callback, &state_mutex);
widget_input_callback_set(widget, input_callback, event_queue); view_port_input_callback_set(view_port, input_callback, event_queue);
// Open GUI and register widget // Open GUI and register view_port
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, widget, GuiLayerFullscreen); gui_add_view_port(gui, view_port, GuiLayerFullscreen);
AppEvent event; AppEvent event;
uint32_t prev_dwt; uint32_t prev_dwt;
@ -290,8 +290,8 @@ void lf_rfid_workaround(void* p) {
gpio_init(pull_pin_record, GpioModeInput); gpio_init(pull_pin_record, GpioModeInput);
gpio_init((GpioPin*)&ibutton_gpio, GpioModeInput); gpio_init((GpioPin*)&ibutton_gpio, GpioModeInput);
// TODO remove all widgets create by app // TODO remove all view_ports create by app
widget_enabled_set(widget, false); view_port_enabled_set(view_port, false);
furiac_exit(NULL); furiac_exit(NULL);
} }
@ -345,7 +345,7 @@ void lf_rfid_workaround(void* p) {
} }
// common code, for example, force update UI // common code, for example, force update UI
widget_update(widget); view_port_update(view_port);
release_mutex(&state_mutex, state); release_mutex(&state_mutex, state);
} }

26
applications/menu/menu.c
View File

@ -14,7 +14,7 @@ struct Menu {
MenuEvent* event; MenuEvent* event;
// GUI // GUI
Widget* widget; ViewPort* view_port;
Icon* icon; Icon* icon;
// State // State
@ -23,7 +23,7 @@ struct Menu {
MenuItem* current; MenuItem* current;
}; };
void menu_widget_callback(Canvas* canvas, void* context); void menu_view_port_callback(Canvas* canvas, void* context);
ValueMutex* menu_init() { ValueMutex* menu_init() {
Menu* menu = furi_alloc(sizeof(Menu)); Menu* menu = furi_alloc(sizeof(Menu));
@ -37,16 +37,16 @@ ValueMutex* menu_init() {
furiac_exit(NULL); furiac_exit(NULL);
} }
// Allocate and configure widget // Allocate and configure view_port
menu->widget = widget_alloc(); menu->view_port = view_port_alloc();
// Open GUI and register fullscreen widget // Open GUI and register fullscreen view_port
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, menu->widget, GuiLayerFullscreen); gui_add_view_port(gui, menu->view_port, GuiLayerFullscreen);
widget_enabled_set(menu->widget, false); view_port_enabled_set(menu->view_port, false);
widget_draw_callback_set(menu->widget, menu_widget_callback, menu_mutex); view_port_draw_callback_set(menu->view_port, menu_view_port_callback, menu_mutex);
widget_input_callback_set(menu->widget, menu_event_input_callback, menu->event); view_port_input_callback_set(menu->view_port, menu_event_input_callback, menu->event);
return menu_mutex; return menu_mutex;
} }
@ -71,7 +71,7 @@ void menu_draw_primary(Menu* menu, Canvas* canvas) {
void menu_draw_secondary(Menu* menu, Canvas* canvas) { void menu_draw_secondary(Menu* menu, Canvas* canvas) {
} }
void menu_widget_callback(Canvas* canvas, void* context) { void menu_view_port_callback(Canvas* canvas, void* context) {
furi_assert(canvas); furi_assert(canvas);
furi_assert(context); furi_assert(context);
@ -148,7 +148,7 @@ void menu_update(Menu* menu) {
} }
menu_event_activity_notify(menu->event); menu_event_activity_notify(menu->event);
widget_update(menu->widget); view_port_update(menu->view_port);
} }
void menu_up(Menu* menu) { void menu_up(Menu* menu) {
@ -176,7 +176,7 @@ void menu_ok(Menu* menu) {
furi_assert(menu); furi_assert(menu);
if(!menu->current) { if(!menu->current) {
widget_enabled_set(menu->widget, true); view_port_enabled_set(menu->view_port, true);
menu->current = menu->root; menu->current = menu->root;
menu_item_set_position(menu->current, 0); menu_item_set_position(menu->current, 0);
menu_update(menu); menu_update(menu);
@ -214,7 +214,7 @@ void menu_back(Menu* menu) {
void menu_exit(Menu* menu) { void menu_exit(Menu* menu) {
furi_assert(menu); furi_assert(menu);
widget_enabled_set(menu->widget, false); view_port_enabled_set(menu->view_port, false);
menu->current = NULL; menu->current = NULL;
menu_update(menu); menu_update(menu);
} }

16
applications/music-player/music-player.c
View File

@ -272,14 +272,14 @@ static void render_callback(Canvas* canvas, void* ctx) {
} }
} }
// volume widget // volume view_port
x_pos = 124; x_pos = 124;
y_pos = 0; y_pos = 0;
const uint8_t volume_h = (64 / (state->volume_id_max - 1)) * state->volume_id; const uint8_t volume_h = (64 / (state->volume_id_max - 1)) * state->volume_id;
canvas_draw_frame(canvas, x_pos, y_pos, 4, 64); canvas_draw_frame(canvas, x_pos, y_pos, 4, 64);
canvas_draw_box(canvas, x_pos, y_pos + (64 - volume_h), 4, volume_h); canvas_draw_box(canvas, x_pos, y_pos + (64 - volume_h), 4, volume_h);
// note stack widget // note stack view_port
x_pos = 73; x_pos = 73;
y_pos = 0; y_pos = 0;
canvas_set_color(canvas, ColorBlack); canvas_set_color(canvas, ColorBlack);
@ -373,13 +373,13 @@ void music_player(void* p) {
furiac_exit(NULL); furiac_exit(NULL);
} }
Widget* widget = widget_alloc(); ViewPort* view_port = view_port_alloc();
widget_draw_callback_set(widget, render_callback, &state_mutex); view_port_draw_callback_set(view_port, render_callback, &state_mutex);
widget_input_callback_set(widget, input_callback, event_queue); view_port_input_callback_set(view_port, input_callback, event_queue);
// Open GUI and register widget // Open GUI and register view_port
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, widget, GuiLayerFullscreen); gui_add_view_port(gui, view_port, GuiLayerFullscreen);
// open input record // open input record
PubSub* input_events_record = furi_record_open("input_events"); PubSub* input_events_record = furi_record_open("input_events");
@ -441,7 +441,7 @@ void music_player(void* p) {
// event timeout // event timeout
} }
widget_update(widget); view_port_update(view_port);
release_mutex(&state_mutex, state); release_mutex(&state_mutex, state);
} }
} }

26
applications/power/power.c
View File

@ -7,7 +7,7 @@
#include <menu/menu_item.h> #include <menu/menu_item.h>
#include <gui/gui.h> #include <gui/gui.h>
#include <gui/widget.h> #include <gui/view_port.h>
#include <gui/view.h> #include <gui/view.h>
#include <gui/view_dispatcher.h> #include <gui/view_dispatcher.h>
#include <gui/modules/dialog.h> #include <gui/modules/dialog.h>
@ -20,10 +20,10 @@ struct Power {
View* info_view; View* info_view;
Icon* usb_icon; Icon* usb_icon;
Widget* usb_widget; ViewPort* usb_view_port;
Icon* battery_icon; Icon* battery_icon;
Widget* battery_widget; ViewPort* battery_view_port;
Dialog* dialog; Dialog* dialog;
@ -124,14 +124,14 @@ Power* power_alloc() {
power->view_dispatcher, PowerViewDialog, dialog_get_view(power->dialog)); power->view_dispatcher, PowerViewDialog, dialog_get_view(power->dialog));
power->usb_icon = assets_icons_get(I_USBConnected_15x8); power->usb_icon = assets_icons_get(I_USBConnected_15x8);
power->usb_widget = widget_alloc(); power->usb_view_port = view_port_alloc();
widget_set_width(power->usb_widget, icon_get_width(power->usb_icon)); view_port_set_width(power->usb_view_port, icon_get_width(power->usb_icon));
widget_draw_callback_set(power->usb_widget, power_draw_usb_callback, power); view_port_draw_callback_set(power->usb_view_port, power_draw_usb_callback, power);
power->battery_icon = assets_icons_get(I_Battery_19x8); power->battery_icon = assets_icons_get(I_Battery_19x8);
power->battery_widget = widget_alloc(); power->battery_view_port = view_port_alloc();
widget_set_width(power->battery_widget, icon_get_width(power->battery_icon)); view_port_set_width(power->battery_view_port, icon_get_width(power->battery_icon));
widget_draw_callback_set(power->battery_widget, power_draw_battery_callback, power); view_port_draw_callback_set(power->battery_view_port, power_draw_battery_callback, power);
return power; return power;
} }
@ -190,8 +190,8 @@ void power_task(void* p) {
} }
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
gui_add_widget(gui, power->usb_widget, GuiLayerStatusBarLeft); gui_add_view_port(gui, power->usb_view_port, GuiLayerStatusBarLeft);
gui_add_widget(gui, power->battery_widget, GuiLayerStatusBarRight); gui_add_view_port(gui, power->battery_view_port, GuiLayerStatusBarRight);
view_dispatcher_attach_to_gui(power->view_dispatcher, gui, ViewDispatcherTypeFullscreen); view_dispatcher_attach_to_gui(power->view_dispatcher, gui, ViewDispatcherTypeFullscreen);
with_value_mutex( with_value_mutex(
@ -217,8 +217,8 @@ void power_task(void* p) {
api_hal_power_get_battery_temperature(ApiHalPowerICFuelGauge); api_hal_power_get_battery_temperature(ApiHalPowerICFuelGauge);
}); });
widget_update(power->battery_widget); view_port_update(power->battery_view_port);
widget_enabled_set(power->usb_widget, api_hal_power_is_charging()); view_port_enabled_set(power->usb_view_port, api_hal_power_is_charging());
osDelay(1000); osDelay(1000);
} }
} }

44
applications/sd-filesystem/sd-filesystem.c
View File

@ -107,22 +107,22 @@ SdApp* sd_app_alloc() {
sd_app->event_queue = osMessageQueueNew(1, sizeof(InputEvent), NULL); sd_app->event_queue = osMessageQueueNew(1, sizeof(InputEvent), NULL);
// init widget // init view_port
sd_app->widget = widget_alloc(); sd_app->view_port = view_port_alloc();
widget_draw_callback_set(sd_app->widget, sd_app_draw_callback, sd_app); view_port_draw_callback_set(sd_app->view_port, sd_app_draw_callback, sd_app);
widget_input_callback_set(sd_app->widget, sd_app_input_callback, sd_app); view_port_input_callback_set(sd_app->view_port, sd_app_input_callback, sd_app);
widget_enabled_set(sd_app->widget, false); view_port_enabled_set(sd_app->view_port, false);
// init lines // init lines
sd_set_lines(sd_app, 0); sd_set_lines(sd_app, 0);
// init icon widget // init icon view_port
sd_app->icon.widget = widget_alloc(); sd_app->icon.view_port = view_port_alloc();
sd_app->icon.mounted = assets_icons_get(I_SDcardMounted_11x8); sd_app->icon.mounted = assets_icons_get(I_SDcardMounted_11x8);
sd_app->icon.fail = assets_icons_get(I_SDcardFail_11x8); sd_app->icon.fail = assets_icons_get(I_SDcardFail_11x8);
widget_set_width(sd_app->icon.widget, icon_get_width(sd_app->icon.mounted)); view_port_set_width(sd_app->icon.view_port, icon_get_width(sd_app->icon.mounted));
widget_draw_callback_set(sd_app->icon.widget, sd_icon_draw_callback, sd_app); view_port_draw_callback_set(sd_app->icon.view_port, sd_icon_draw_callback, sd_app);
widget_enabled_set(sd_app->icon.widget, false); view_port_enabled_set(sd_app->icon.view_port, false);
return sd_app; return sd_app;
} }
@ -153,7 +153,7 @@ bool app_sd_ask(SdApp* sd_app, Input input_true, Input input_false) {
void app_sd_info_callback(void* context) { void app_sd_info_callback(void* context) {
furi_assert(context); furi_assert(context);
SdApp* sd_app = context; SdApp* sd_app = context;
widget_enabled_set(sd_app->widget, true); view_port_enabled_set(sd_app->view_port, true);
// dynamic strings // dynamic strings
const uint8_t str_buffer_size = 26; const uint8_t str_buffer_size = 26;
@ -257,7 +257,7 @@ void app_sd_info_callback(void* context) {
app_sd_ask(sd_app, InputBack, InputBack); app_sd_ask(sd_app, InputBack, InputBack);
sd_set_lines(sd_app, 0); sd_set_lines(sd_app, 0);
widget_enabled_set(sd_app->widget, false); view_port_enabled_set(sd_app->view_port, false);
for(uint8_t i = 0; i < str_count; i++) { for(uint8_t i = 0; i < str_count; i++) {
free(str_buffer[i]); free(str_buffer[i]);
@ -291,11 +291,11 @@ void app_sd_format_callback(void* context) {
// ask to really format // ask to really format
sd_set_lines(sd_app, 2, "Press UP to format", "or BACK to exit"); sd_set_lines(sd_app, 2, "Press UP to format", "or BACK to exit");
widget_enabled_set(sd_app->widget, true); view_port_enabled_set(sd_app->view_port, true);
// wait for input // wait for input
if(!app_sd_ask(sd_app, InputUp, InputBack)) { if(!app_sd_ask(sd_app, InputUp, InputBack)) {
widget_enabled_set(sd_app->widget, false); view_port_enabled_set(sd_app->view_port, false);
return; return;
} }
@ -315,7 +315,7 @@ void app_sd_format_callback(void* context) {
// wait for BACK // wait for BACK
app_sd_ask(sd_app, InputBack, InputBack); app_sd_ask(sd_app, InputBack, InputBack);
widget_enabled_set(sd_app->widget, false); view_port_enabled_set(sd_app->view_port, false);
} }
void app_sd_unmount_card(SdApp* sd_app) { void app_sd_unmount_card(SdApp* sd_app) {
@ -323,7 +323,7 @@ void app_sd_unmount_card(SdApp* sd_app) {
// set status // set status
sd_app->info.status = SD_NO_CARD; sd_app->info.status = SD_NO_CARD;
widget_enabled_set(sd_app->icon.widget, false); view_port_enabled_set(sd_app->icon.view_port, false);
// close files // close files
for(uint8_t index = 0; index < SD_FS_MAX_FILES; index++) { for(uint8_t index = 0; index < SD_FS_MAX_FILES; index++) {
@ -350,7 +350,7 @@ void app_sd_eject_callback(void* context) {
SdApp* sd_app = context; SdApp* sd_app = context;
sd_set_lines(sd_app, 1, "ejecting SD card"); sd_set_lines(sd_app, 1, "ejecting SD card");
widget_enabled_set(sd_app->widget, true); view_port_enabled_set(sd_app->view_port, true);
app_sd_unmount_card(sd_app); app_sd_unmount_card(sd_app);
@ -359,7 +359,7 @@ void app_sd_eject_callback(void* context) {
// wait for BACK // wait for BACK
app_sd_ask(sd_app, InputBack, InputBack); app_sd_ask(sd_app, InputBack, InputBack);
widget_enabled_set(sd_app->widget, false); view_port_enabled_set(sd_app->view_port, false);
} }
static void cli_sd_status(string_t args, void* _ctx) { static void cli_sd_status(string_t args, void* _ctx) {
@ -484,8 +484,8 @@ void sd_filesystem(void* p) {
Cli* cli = furi_record_open("cli"); Cli* cli = furi_record_open("cli");
ValueMutex* menu_vm = furi_record_open("menu"); ValueMutex* menu_vm = furi_record_open("menu");
gui_add_widget(gui, sd_app->widget, GuiLayerFullscreen); gui_add_view_port(gui, sd_app->view_port, GuiLayerFullscreen);
gui_add_widget(gui, sd_app->icon.widget, GuiLayerStatusBarLeft); gui_add_view_port(gui, sd_app->icon.view_port, GuiLayerStatusBarLeft);
cli_add_command(cli, "sd_status", cli_sd_status, sd_app); cli_add_command(cli, "sd_status", cli_sd_status, sd_app);
cli_add_command(cli, "sd_format", cli_sd_format, sd_app); cli_add_command(cli, "sd_format", cli_sd_format, sd_app);
@ -540,14 +540,14 @@ void sd_filesystem(void* p) {
} }
} }
widget_enabled_set(sd_app->icon.widget, true); view_port_enabled_set(sd_app->icon.view_port, true);
sd_was_present = false; sd_was_present = false;
} }
} else { } else {
if(!hal_gpio_read_sd_detect()) { if(!hal_gpio_read_sd_detect()) {
printf("[sd_filesystem] card removed\r\n"); printf("[sd_filesystem] card removed\r\n");
widget_enabled_set(sd_app->icon.widget, false); view_port_enabled_set(sd_app->icon.view_port, false);
app_sd_unmount_card(sd_app); app_sd_unmount_card(sd_app);
sd_was_present = true; sd_was_present = true;
} }

4
applications/sd-filesystem/sd-filesystem.h
View File

@ -63,7 +63,7 @@ typedef struct {
/* application data */ /* application data */
typedef struct { typedef struct {
Widget* widget; ViewPort* view_port;
Icon* mounted; Icon* mounted;
Icon* fail; Icon* fail;
} SdFsIcon; } SdFsIcon;
@ -80,7 +80,7 @@ typedef struct {
SdFsInfo info; SdFsInfo info;
SdFsIcon icon; SdFsIcon icon;
Widget* widget; ViewPort* view_port;
const char* line[SD_STATE_LINES_COUNT]; const char* line[SD_STATE_LINES_COUNT];
osMessageQueueId_t event_queue; osMessageQueueId_t event_queue;
} SdApp; } SdApp;

12
applications/template/template.c.example
View File

@ -48,18 +48,18 @@ void template_app(void* p) {
furiac_exit(NULL); furiac_exit(NULL);
} }
Widget* widget = widget_alloc(); ViewPort* view_port = view_port_alloc();
widget_draw_callback_set(widget, render_callback, &state_mutex); view_port_draw_callback_set(view_port, render_callback, &state_mutex);
widget_input_callback_set(widget, input_callback, event_queue); view_port_input_callback_set(view_port, input_callback, event_queue);
// Open GUI and register widget // Open GUI and register view_port
Gui* gui = furi_record_open("gui"); Gui* gui = furi_record_open("gui");
if(gui == NULL) { if(gui == NULL) {
printf("gui is not available\r\n"); printf("gui is not available\r\n");
furiac_exit(NULL); furiac_exit(NULL);
} }
gui_add_widget(gui, widget, /* specify UI layer */); gui_add_view_port(gui, view_port, /* specify UI layer */);
Event event; Event event;
while(1) { while(1) {
@ -95,7 +95,7 @@ void template_app(void* p) {
} }
// common code, for example, force update UI // common code, for example, force update UI
// widget_update(widget); // view_port_update(view_port);
release_mutex(&state_mutex, state); release_mutex(&state_mutex, state);
} }

24
lib/app-template/app-template.h
View File

@ -7,7 +7,7 @@
// simple app class with template variables <state, events> // simple app class with template variables <state, events>
template <class TState, class TEvent> class AppTemplate { template <class TState, class TEvent> class AppTemplate {
public: public:
Widget* widget; ViewPort* view_port;
osMessageQueueId_t event_queue; osMessageQueueId_t event_queue;
TState state; TState state;
ValueMutex state_mutex; ValueMutex state_mutex;
@ -40,8 +40,8 @@ template <class TState, class TEvent> AppTemplate<TState, TEvent>::AppTemplate()
// open gui // open gui
gui = (Gui*)furi_record_open("gui"); gui = (Gui*)furi_record_open("gui");
// allocate widget // allocate view_port
widget = widget_alloc(); view_port = view_port_alloc();
} }
template <class TState, class TEvent> AppTemplate<TState, TEvent>::~AppTemplate() { template <class TState, class TEvent> AppTemplate<TState, TEvent>::~AppTemplate() {
@ -88,24 +88,24 @@ bool AppTemplate<TState, TEvent>::get_event(TEvent* event, uint32_t timeout) {
// signal that app is ready, and we can render something // signal that app is ready, and we can render something
// also unblock dependent tasks // also unblock dependent tasks
template <class TState, class TEvent> void AppTemplate<TState, TEvent>::app_ready(void) { template <class TState, class TEvent> void AppTemplate<TState, TEvent>::app_ready(void) {
// connect widget with input callback // connect view_port with input callback
auto input_cb_ref = cbc::obtain_connector(this, &AppTemplate::input_callback); auto input_cb_ref = cbc::obtain_connector(this, &AppTemplate::input_callback);
widget_input_callback_set(widget, input_cb_ref, this); view_port_input_callback_set(view_port, input_cb_ref, this);
// connect widget with draw callback // connect view_port with draw callback
auto draw_cb_ref = cbc::obtain_connector(this, &AppTemplate::draw_callback); auto draw_cb_ref = cbc::obtain_connector(this, &AppTemplate::draw_callback);
widget_draw_callback_set(widget, draw_cb_ref, this); view_port_draw_callback_set(view_port, draw_cb_ref, this);
// add widget // add view_port
gui_add_widget(gui, widget, GuiLayerFullscreen); gui_add_view_port(gui, view_port, GuiLayerFullscreen);
} }
template <class TState, class TEvent> void AppTemplate<TState, TEvent>::exit(void) { template <class TState, class TEvent> void AppTemplate<TState, TEvent>::exit(void) {
// TODO remove all widgets create by app // TODO remove all view_ports create by app
widget_enabled_set(widget, false); view_port_enabled_set(view_port, false);
osThreadExit(); osThreadExit();
} }
template <class TState, class TEvent> void AppTemplate<TState, TEvent>::update_gui(void) { template <class TState, class TEvent> void AppTemplate<TState, TEvent>::update_gui(void) {
widget_update(widget); view_port_update(view_port);
} }