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

applications/gui/gui.c

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

applications/gui/gui.h

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

applications/gui/view.h

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

applications/gui/view_dispatcher.c

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

applications/gui/view_dispatcher.h

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

applications/gui/view_dispatcher_i.h

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

applications/gui/view_port.c

@@ -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);
+    }
+}

applications/gui/view_port.h

@@ -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

applications/gui/view_port_i.h

@@ -1,39 +1,39 @@
 #pragma once
 
 #include "gui_i.h"
-#include "widget.h"
+#include "view_port.h"
 
-struct Widget {
+struct ViewPort {
     Gui* gui;
     bool is_enabled;
 
     uint8_t width;
     uint8_t height;
 
-    WidgetDrawCallback draw_callback;
+    ViewPortDrawCallback draw_callback;
     void* draw_callback_context;
 
-    WidgetInputCallback input_callback;
+    ViewPortInputCallback input_callback;
     void* input_callback_context;
 };
 
 /*
  * 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.
  */
-void widget_gui_set(Widget* widget, Gui* gui);
+void view_port_gui_set(ViewPort* view_port, Gui* gui);
 
 /*
  * Process draw call. Calls draw callback.
  * To be used by GUI, called on tree redraw.
  * @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
  * To be used by GUI, called on input dispatch.
  * @param event - pointer to input event.
  */
-void widget_input(Widget* widget, InputEvent* event);
+void view_port_input(ViewPort* view_port, InputEvent* event);

applications/gui/widget.c

@@ -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);
-    }
-}

applications/gui/widget.h

@@ -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