sys logging added; power management reimplemented; bugfixes;

9 files changed, 483 insertions, 364 deletions

diff --git a/fw/fe310/eos/eve/screen/form.c b/fw/fe310/eos/eve/screen/form.c
index 3e5b97c..de03bfd 100644
--- a/fw/fe310/eos/eve/screen/form.c
+++ b/fw/fe310/eos/eve/screen/form.c
@@ -12,7 +12,8 @@
 #define MIN(X, Y)               (((X) < (Y)) ? (X) : (Y))
 #define MAX(X, Y)               (((X) > (Y)) ? (X) : (Y))
 
-static void widgets_destroy(EVEWidget *widget, uint16_t widget_size) {
+static void widgets_destroy(EVEWidget *widgets, uint16_t widget_size) {
+    EVEWidget *widget = widgets;
     int i;
 
     for (i=0; i<widget_size; i++) {
@@ -20,65 +21,60 @@ static void widgets_destroy(EVEWidget *widget, uint16_t widget_size) {
         eve_widget_destroy(widget);
         widget = eve_widget_next(widget);
     }
+    eve_free(widgets);
 }
 
-EVEPage *eve_form_create(EVEWindow *window, EVEViewStack *stack, EVEFormSpec spec[], uint16_t spec_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor) {
+int eve_form_create(EVEPage *page, EVEWindow *window, EVEVStack *stack, EVEFormSpec spec[], uint16_t spec_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor) {
     EVEWidget *widgets;
     EVEWidget *widget;
     EVELabel *label;
-    EVEPage *page;
     int w_size = 0;
-    int i, r;
+    int i, rv;
 
     if (uievt == NULL) uievt = eve_form_uievt;
     if (destructor == NULL) destructor = eve_form_destroy;
-    page = eve_malloc(sizeof(EVEPage));
-    if (page == NULL) {
-        return NULL;
-    }
-    eve_form_init(page, window, stack, NULL, 0, uievt, destructor);
 
     for (i=0; i<spec_size; i++) {
         w_size += eve_widget_size(spec[i].widget.type);
     }
     widgets = eve_malloc(w_size);
     if (widgets == NULL) {
-        eve_free(page);
-        return NULL;
+        return EVE_ERR_NOMEM;
     }
 
+    eve_form_init(page, window, stack, NULL, 0, uievt, destructor);
+
     widget = widgets;
     for (i=0; i<spec_size; i++) {
-        r = eve_widget_create(widget, &spec[i].widget, page);
-        if (r) {
+        rv = eve_widget_create(widget, &spec[i].widget, page);
+        if (rv) {
             widgets_destroy(widgets, i);
-            eve_free(widgets);
-            eve_free(page);
-            return NULL;
+            return rv;
         }
         if (spec[i].label.title) {
+            rv = EVE_OK;
             label = eve_malloc(sizeof(EVELabel));
-            if (label == NULL) {
+            if (label) rv = eve_label_create(label, &spec[i].label, page);
+            if ((label == NULL) || rv) {
+                if (label) eve_free(label);
                 eve_widget_destroy(widget);
                 widgets_destroy(widgets, i);
-                eve_free(widgets);
-                eve_free(page);
-                return NULL;
+                return label ? rv : EVE_ERR_NOMEM;
             }
-            eve_label_create(label, &spec[i].label, page);
             eve_widget_set_label(widget, label);
         }
-        if (widget->g.w == 0) widget->g.w = window->g.w - (widget->label ? widget->label->g.w : 0);
+        if ((widget->g.w == 0) && widget->label) widget->g.w = window->g.w - widget->label->g.w;
+        if (widget->g.w == 0) widget->g.w = window->g.w;
         widget = eve_widget_next(widget);
     }
     eve_form_set_widget(page, widgets, spec_size);
 
-    return page;
+    return EVE_OK;
 }
 
-void eve_form_init(EVEPage *page, EVEWindow *window, EVEViewStack *stack, EVEWidget *widget, uint16_t widget_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor) {
-    eve_page_init(page, window, stack, NULL, 0, EVE_PAGE_OPT_SCROLL_Y | EVE_PAGE_OPT_SCROLL_BACK | EVE_PAGE_OPT_TRACK_EXT_Y, eve_page_draw, eve_page_touch, uievt, destructor);
-    if (widget) eve_form_set_widget(page, widget, widget_size);
+void eve_form_init(EVEPage *page, EVEWindow *window, EVEVStack *stack, EVEWidget *widget, uint16_t widget_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor) {
+    eve_page_init(page, window, stack, widget, widget_size, EVE_PAGE_OPT_SCROLL_Y | EVE_PAGE_OPT_SCROLL_BACK | EVE_PAGE_OPT_TRACK_EXT_Y, eve_page_draw, eve_page_touch, uievt, destructor);
+    if (widget) eve_form_update_g(page, NULL);
 }
 
 void eve_form_set_widget(EVEPage *page, EVEWidget *widget, uint16_t widget_size) {
@@ -88,42 +84,24 @@ void eve_form_set_widget(EVEPage *page, EVEWidget *widget, uint16_t widget_size)
 
 void eve_form_destroy(EVEPage *page) {
     widgets_destroy(page->widget, page->widget_size);
-    eve_free(page->widget);
-    eve_free(page);
 }
 
-int eve_form_uievt(EVEPage *page, uint16_t evt, void *param) {
+void eve_form_uievt(EVEPage *page, uint16_t evt, void *param) {
     switch (evt) {
         case EVE_UIEVT_WIDGET_UPDATE_G:
             eve_form_update_g(page, (EVEWidget *)param);
             break;
 
-        case EVE_UIEVT_WIDGET_FOCUS_IN:
-            break;
-
-        case EVE_UIEVT_WIDGET_FOCUS_OUT:
-            break;
-
-        case EVE_UIEVT_GEST_SCROLL_START:
-            break;
-
-        case EVE_UIEVT_GEST_SCROLL_STOP:
-            break;
-
-        case EVE_UIEVT_GEST_TRACK_START:
-            break;
-
         case EVE_UIEVT_GEST_TRACK_STOP: {
             EVEUIEvtTouch *touch_p = (EVEUIEvtTouch *)param;
 
             if (touch_p->touch->eevt & EVE_TOUCH_EETYPE_TRACK_RIGHT) {
                 eve_page_close(page);
-                return 1;
+                return;
             }
             break;
         }
     }
-    return 0;
 }
 
 void eve_form_update_g(EVEPage *page, EVEWidget *_widget) {
diff --git a/fw/fe310/eos/eve/screen/form.h b/fw/fe310/eos/eve/screen/form.h
index bc81d2d..c4b8493 100644
--- a/fw/fe310/eos/eve/screen/form.h
+++ b/fw/fe310/eos/eve/screen/form.h
@@ -7,10 +7,10 @@ typedef struct EVEFormSpec {
     EVEWidgetSpec widget;
 } EVEFormSpec;
 
-EVEPage *eve_form_create(EVEWindow *window, EVEViewStack *stack, EVEFormSpec spec[], uint16_t spec_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor);
-void eve_form_init(EVEPage *page, EVEWindow *window, EVEViewStack *stack, EVEWidget *widget, uint16_t widget_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor);
+int eve_form_create(EVEPage *page, EVEWindow *window, EVEVStack *stack, EVEFormSpec spec[], uint16_t spec_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor);
+void eve_form_init(EVEPage *page, EVEWindow *window, EVEVStack *stack, EVEWidget *widget, uint16_t widget_size, eve_page_uievt_t uievt, eve_page_destructor_t destructor);
 void eve_form_set_widget(EVEPage *page, EVEWidget *widget, uint16_t widget_size);
 void eve_form_destroy(EVEPage *page);
 
-int eve_form_uievt(EVEPage *page, uint16_t evt, void *param);
+void eve_form_uievt(EVEPage *page, uint16_t evt, void *param);
 void eve_form_update_g(EVEPage *page, EVEWidget *_widget);
diff --git a/fw/fe310/eos/eve/screen/page.c b/fw/fe310/eos/eve/screen/page.c
index 93b81c5..8c02538 100644
--- a/fw/fe310/eos/eve/screen/page.c
+++ b/fw/fe310/eos/eve/screen/page.c
@@ -14,15 +14,36 @@
 #define PAGE_TMODE_TRACK    1
 #define PAGE_TMODE_SCROLL   2
 
-void eve_page_init(EVEPage *page, EVEWindow *window, EVEViewStack *stack, EVEWidget *widget, uint16_t widget_size, uint8_t opt, eve_page_draw_t draw, eve_page_touch_t touch, eve_page_uievt_t uievt, eve_page_destructor_t destructor) {
+void eve_page_init(EVEPage *page, EVEWindow *window, EVEVStack *stack, EVEWidget *widget, uint16_t widget_size, uint8_t opt, eve_page_draw_t draw, eve_page_touch_t touch, eve_page_uievt_t uievt, eve_page_destructor_t destructor) {
     memset(page, 0, sizeof(EVEPage));
     eve_view_init(&page->v, window, (eve_view_draw_t)draw, (eve_view_touch_t)touch, (eve_view_uievt_t)uievt, NULL);
+    eve_phy_lho_init(&page->lho, 100, 0.5, 0);
     page->stack = stack;
     page->opt = opt;
     page->destructor = destructor;
     eve_page_set_widget(page, widget, widget_size);
 }
 
+void eve_page_attach(EVEPage *page, EVEWindow *window, void *page_id) {
+    eve_view_attach(&page->v, window, page_id);
+}
+
+void eve_page_detach(EVEPage *page) {
+    eve_view_detach(&page->v);
+}
+
+void eve_page_set_param(EVEPage *page, void *param) {
+    eve_view_set_param(&page->v, param);
+}
+
+EVEView *eve_page_view(EVEPage *page) {
+    return &page->v;
+}
+
+EVEPage *eve_page_from_view(EVEView *view) {
+    return (EVEPage *)view;
+}
+
 EVEWidget *eve_page_widget(EVEPage *page, uint16_t _idx) {
     EVEWidget *w = page->widget;
     int i, idx;
@@ -62,53 +83,81 @@ void eve_page_set_widget(EVEPage *page, EVEWidget *widget, uint16_t widget_size)
     page->widget_size = widget_size;
 }
 
-void eve_page_open(EVEPage *parent, eve_view_constructor_t constructor) {
-    EVEWindow *window = parent->v.window;
-    EVEViewStack *stack = parent->stack;
-    eve_page_destructor_t destructor = parent->destructor;
-
-    eve_page_set_focus(parent, NULL);
-    if (destructor) destructor(parent);
-    eve_stack_create_view(stack, window, constructor);
-}
-
-void eve_page_close(EVEPage *page) {
+static void page_destroy(EVEPage *page) {
     EVEWindow *window = page->v.window;
-    EVEViewStack *stack = page->stack;
     eve_page_destructor_t destructor = page->destructor;
 
-    if (stack->level <= 1) return;
-
     eve_page_set_focus(page, NULL);
-    if (eve_timer_running()) {
-        eve_timer_stop();
-    }
-    if (eve_window_scroll(window->root, NULL) == window) {
+    if (eve_window_scroll(window, NULL) == window) {
         eve_window_scroll_stop(window);
     }
 
     eve_window_kbd_detach(window);
 
+    eve_page_detach(page);
+
     if (destructor) destructor(page);
-    eve_stack_back(stack, window);
+}
+
+void eve_page_open(EVEPage *parent, eve_view_constructor_t constructor) {
+    EVEWindow *window = parent->v.window;
+    EVEVStack *stack = parent->stack;
+    int rv;
+
+    if (eve_vstack_full(stack)) return;
+
+    page_destroy(parent);
+    rv = eve_vstack_create_view(stack, window, constructor);
+    if (rv) {
+        EVEView *view = NULL;
+
+        do {
+            constructor = eve_vstack_get(stack);
+            if (constructor) view = constructor(window, stack);
+            if (view == NULL) eve_vstack_pull(stack);
+        } while ((view == NULL) && constructor);
+        if (view) eve_view_attach(view, window, constructor);
+    }
+}
+
+void eve_page_close(EVEPage *page) {
+    EVEWindow *window = page->v.window;
+    EVEVStack *stack = page->stack;
+    int rv;
+
+    if (eve_vstack_level(stack) == 1) return;
+
+    page_destroy(page);
+    rv = eve_vstack_back(stack, window);
+    if (rv) {
+        eve_view_constructor_t constructor;
+        EVEView *view = NULL;
+
+        do {
+            eve_vstack_pull(stack);
+            constructor = eve_vstack_get(stack);
+            if (constructor) view = constructor(window, stack);
+        } while ((view == NULL) && constructor);
+        if (view) eve_view_attach(view, window, constructor);
+    }
 }
 
 /* Screen to page coordinates */
 int16_t eve_page_x(EVEPage *page, int16_t x) {
-    return x + page->g.x - page->v.window->g.x;
+    return x - page->g.x - page->v.window->g.x;
 }
 
 int16_t eve_page_y(EVEPage *page, int16_t y) {
-    return y + page->g.y - page->v.window->g.y;
+    return y - page->g.y - page->v.window->g.y;
 }
 
 /* Page to window coordinates */
 int16_t eve_page_win_x(EVEPage *page, int16_t x) {
-    return x - page->g.x;
+    return x + page->g.x;
 }
 
 int16_t eve_page_win_y(EVEPage *page, int16_t y) {
-    return y - page->g.y;
+    return y + page->g.y;
 }
 
 /* Page to screen coordinates */
@@ -120,49 +169,57 @@ int16_t eve_page_scr_y(EVEPage *page, int16_t y) {
     return eve_page_win_y(page, y) + page->v.window->g.y;
 }
 
-int eve_page_rect_visible(EVEPage *page, EVERect *g) {
-    uint16_t w = page->v.window->g.w;
-    uint16_t h = page->v.window->g.h;
+int eve_page_rect_visible(EVEPage *page, EVERect *rect) {
+    EVERect win_g;
 
-    if (((g->x + g->w) >= page->g.x) && ((g->y + g->h) >= page->g.y) && (g->x <= (page->g.x + w)) && (g->y <= (page->g.y + h))) return 1;
-    return 0;
+    eve_window_visible_g(page->v.window, &win_g);
+    win_g.x -= page->v.window->g.x;
+    win_g.y -= page->v.window->g.y;
+
+    if ((page->g.x + rect->x + rect->w < win_g.x) ||
+        (page->g.y + rect->y + rect->h < win_g.y) ||
+        (page->g.x + rect->x > win_g.x + win_g.w) ||
+        (page->g.y + rect->y > win_g.y + win_g.h)) return 0;
+
+    return 1;
 }
 
 void eve_page_show_rect(EVEPage *page, EVERect *rect) {
-    EVERect g;
+    EVERect win_g;
 
-    eve_window_visible_g(page->v.window, &g);
-    g.x -= page->v.window->g.x;
-    g.y -= page->v.window->g.y;
+    eve_window_visible_g(page->v.window, &win_g);
+    win_g.x -= page->v.window->g.x;
+    win_g.y -= page->v.window->g.y;
 
-    if (rect->x < page->g.x + g.x) {
-        page->g.x = rect->x - g.x;
+    if (page->g.x + rect->x < win_g.x) {
+        page->g.x = win_g.x - rect->x;
     }
-    if (rect->y < page->g.y + g.y) {
-        page->g.y = rect->y - g.y;
+    if (page->g.y + rect->y < win_g.y) {
+        page->g.y = win_g.y - rect->y;
     }
-    if ((rect->x + rect->w) > (page->g.x + g.x + g.w)) {
-        page->g.x = (rect->x + rect->w) - (g.x + g.w);
+
+    if (page->g.x + rect->x + rect->w > win_g.x + win_g.w) {
+        page->g.x = win_g.x + win_g.w - (rect->x + rect->w);
     }
-    if ((rect->y + rect->h) > (page->g.y + g.y + g.h)) {
-        page->g.y = (rect->y + rect->h) - (g.y + g.h);
+    if (page->g.y + rect->y + rect->h > win_g.y + win_g.h) {
+        page->g.y = win_g.y + win_g.h - (rect->y + rect->h);
     }
 }
 
 /* returns true if x or y are out of page bounds for window */
-int eve_page_oob(EVEPage *page, int *_max_x, int *_max_y) {
-    int max_x, max_y;
-    EVERect vg;
+int eve_page_oob(EVEPage *page, int *min_x, int *min_y) {
+    int _min_x, _min_y;
+    EVERect win_g;
 
-    eve_window_visible_g(page->v.window, &vg);
-    max_x = page->g.w > vg.w ? page->g.w - vg.w : 0;
-    max_y = page->g.h > vg.h ? page->g.h - vg.h : 0;
+    eve_window_visible_g(page->v.window, &win_g);
+    _min_x = -(page->g.w > win_g.w ? page->g.w - win_g.w : 0);
+    _min_y = -(page->g.h > win_g.h ? page->g.h - win_g.h : 0);
 
-    if (_max_x) *_max_x = max_x;
-    if (_max_y) *_max_y = max_y;
+    if (min_x) *min_x = _min_x;
+    if (min_y) *min_y = _min_y;
 
-    return ((page->g.x < 0) || (page->g.x > max_x) ||
-            (page->g.y < 0) || (page->g.y > max_y));
+    return ((page->g.x > 0) || (page->g.x < _min_x) ||
+            (page->g.y > 0) || (page->g.y < _min_y));
 }
 
 EVEWidget *eve_page_focus(EVEPage *page) {
@@ -174,159 +231,150 @@ void eve_page_set_focus(EVEPage *page, EVEWidget *widget) {
         EVEWindow *window = page->v.window;
         EVEWidget *widget_f = page->widget_f;
 
-        if (widget_f && widget_f->putc) {
-            widget_f->putc(widget_f, EVE_PAGE_KBDCH_CLOSE);
-            if (!(widget && widget->putc)) eve_window_kbd_detach(window);
+        if ((widget_f && widget_f->putc) && !(widget && widget->putc)) {
+            eve_window_kbd_detach(window);
         }
         if (widget && widget->putc) {
             EVEKbd *kbd = eve_window_kbd(window);
 
             if (kbd) eve_kbd_set_handler(kbd, widget->putc, widget);
-            if (!(widget_f && widget_f->putc)) eve_window_kbd_attach(window);
+            if (!(widget_f && widget_f->putc)) {
+                eve_window_kbd_attach(window);
+                eve_page_show_rect(page, &widget->g);
+            }
+        }
+        if (widget_f) {
+            eve_view_uievt_push(&page->v, EVE_UIEVT_WIDGET_FOCUS_OUT, widget_f);
+            widget_f->touch(widget_f, NULL, EVE_TOUCH_ETYPE_EXT | EVE_UIEVT_WIDGET_FOCUS_OUT);
         }
-        if (page->widget_f) eve_view_uievt_push(&page->v, EVE_UIEVT_WIDGET_FOCUS_OUT, page->widget_f);
         page->widget_f = widget;
-        if (page->widget_f) eve_view_uievt_push(&page->v, EVE_UIEVT_WIDGET_FOCUS_IN, page->widget_f);
+        if (widget) {
+            eve_view_uievt_push(&page->v, EVE_UIEVT_WIDGET_FOCUS_IN, widget);
+            widget->touch(widget, NULL, EVE_TOUCH_ETYPE_EXT | EVE_UIEVT_WIDGET_FOCUS_IN);
+        }
     }
 }
 
-static int page_touch(EVEPage *page, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+static int page_touch(EVEPage *page, EVETouch *touch, uint16_t evt) {
     EVEView *view = &page->v;
     EVEWindow *window = view->window;
     int scroll_x = 0, scroll_y = 0, scroll;
-    int ret = 0;
-
-    if (touch) {
-        if ((page->opt & EVE_PAGE_OPT_SCROLL_XY) == EVE_PAGE_OPT_SCROLL_XY) {
-            scroll_x = scroll_y = (touch->eevt & EVE_TOUCH_EETYPE_TRACK_XY);
-        } else if (page->opt & EVE_PAGE_OPT_SCROLL_X) {
-            scroll_x = (touch->eevt & EVE_TOUCH_EETYPE_TRACK_X);
-        } else if (page->opt & EVE_PAGE_OPT_SCROLL_Y) {
-            scroll_y = (touch->eevt & EVE_TOUCH_EETYPE_TRACK_Y);
-        }
+    int rv = 0;
+
+    if ((page->opt & EVE_PAGE_OPT_SCROLL_XY) == EVE_PAGE_OPT_SCROLL_XY) {
+        scroll_x = scroll_y = (touch->eevt & EVE_TOUCH_EETYPE_TRACK_XY);
+    } else if (page->opt & EVE_PAGE_OPT_SCROLL_X) {
+        scroll_x = (touch->eevt & EVE_TOUCH_EETYPE_TRACK_X);
+    } else if (page->opt & EVE_PAGE_OPT_SCROLL_Y) {
+        scroll_y = (touch->eevt & EVE_TOUCH_EETYPE_TRACK_Y);
+    }
 
-        scroll = scroll_x || scroll_y;
+    scroll = scroll_x || scroll_y;
 
-        if ((tag0 == page->v.tag) && (evt & EVE_TOUCH_ETYPE_POINT_UP) && !(touch->eevt & (EVE_TOUCH_EETYPE_TRACK_XY | EVE_TOUCH_EETYPE_ABORT))) {
-            int _ret = 0;
+    if ((touch->tag0 == page->v.tag) && (evt & EVE_TOUCH_ETYPE_POINT_UP) && !(touch->eevt & (EVE_TOUCH_EETYPE_TRACK_XY | EVE_TOUCH_EETYPE_TRACK_ABORT))) {
+        eve_page_set_focus(page, NULL);
+        eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_TOUCH, touch, evt);
+        if (eve_window_dirty(window)) return 1;
+        rv = 1;
+    }
 
-            eve_page_set_focus(page, NULL);
-            _ret = eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_TOUCH, touch, evt, tag0);
-            if (_ret) return _ret;
-            ret = 1;
+    /* Scroll / track start */
+    if (evt & EVE_TOUCH_ETYPE_TRACK_START) {
+        if (page->track_mode == PAGE_TMODE_NONE) {
+            if (scroll) {
+                page->track_mode = PAGE_TMODE_SCROLL;
+                eve_window_scroll_start(window, touch->tag0);
+                eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_SCROLL_START, touch, evt);
+            } else {
+                page->track_mode = PAGE_TMODE_TRACK;
+                eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_TRACK_START, touch, evt);
+            }
+            if (eve_window_dirty(window)) return 1;
+        }
+        if (scroll_x) {
+            page->x0 = touch->x0 - page->g.x;
+        }
+        if (scroll_y) {
+            page->y0 = touch->y0 - page->g.y;
         }
+        rv = 1;
+    }
 
-        /* Scroll / track start */
-        if (evt & EVE_TOUCH_ETYPE_TRACK_START) {
-            int _ret = 0;
-
-            if (!(touch->eevt & EVE_TOUCH_EETYPE_ABORT)) {
-                if (scroll) {
-                    page->track_mode = PAGE_TMODE_SCROLL;
-                    eve_window_scroll_start(window, touch->tracker.tag);
-                    _ret = eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_SCROLL_START, touch, evt, tag0);
-                } else {
-                    page->track_mode = PAGE_TMODE_TRACK;
-                    _ret = eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_TRACK_START, touch, evt, tag0);
-                }
-                if (_ret) return _ret;
-            }
-            if (scroll_x) {
-                page->x0 = page->g.x;
-            }
-            if (scroll_y) {
-                page->y0 = page->g.y;
-            }
-            ret = 1;
+    if ((evt & EVE_TOUCH_ETYPE_TRACK) && (page->track_mode == PAGE_TMODE_SCROLL)) {
+        if (scroll_x) {
+            page->g.x = touch->x - page->x0;
         }
+        if (scroll_y) {
+            page->g.y = touch->y - page->y0;
+        }
+        rv = 1;
+    }
 
-        /* Scroll / track stop */
-        if (((evt & EVE_TOUCH_ETYPE_TRACK_STOP) && !(evt & EVE_TOUCH_ETYPE_TRACK_ABORT)) ||
-            ((evt & EVE_TOUCH_ETYPE_POINT_UP) && (touch->eevt & EVE_TOUCH_EETYPE_ABORT) && !(touch->eevt & EVE_TOUCH_EETYPE_TRACK_XY))) {
-            if ((page->track_mode == PAGE_TMODE_SCROLL) && (page->opt & EVE_PAGE_OPT_SCROLL_BACK)) {
-                int max_x, max_y;
-                int oob;
-
-                oob = eve_page_oob(page, &max_x, &max_y);
-                if (oob) {
-                    int lho_x, lho_y;
-                    uint8_t _tag;
-                    EVEPhyLHO *lho = &page->lho;
-
-                    lho_x = page->g.x < 0 ? 0 : max_x;
-                    lho_y = page->g.y < 0 ? 0 : max_y;
-                    eve_window_scroll(window->root, &_tag);
-
-                    page->lho_t0 = eve_get_tick();
-                    eve_phy_lho_init(lho, lho_x, lho_y, 100, 0.5, 0);
-                    eve_phy_lho_start(lho, page->g.x, page->g.y);
-                    eve_timer_start(_tag, 20);
+    /* Scroll / track stop */
+    if (((evt & EVE_TOUCH_ETYPE_TRACK_STOP) && !(evt & EVE_TOUCH_ETYPE_TRACK_ABORT)) ||
+        ((evt & EVE_TOUCH_ETYPE_POINT_UP) && (touch->eevt & EVE_TOUCH_EETYPE_TRACK_ABORT) && !(touch->eevt & EVE_TOUCH_EETYPE_TRACK_XY))) {
+        int start = 0;
+
+        if ((page->track_mode == PAGE_TMODE_SCROLL) && (page->opt & EVE_PAGE_OPT_SCROLL_BACK)) {
+            int min_gx, min_gy;
+            int oob;
+
+            oob = eve_page_oob(page, &min_gx, &min_gy);
+            if (oob) {
+                int pivot_x, pivot_y, x0, y0;
+                int scroll_x, scroll_y;
+                EVEPhyLHO *lho = &page->lho;
+                uint8_t scroll_tag;
+
+                pivot_x = touch->x0 - page->g.x + (page->g.x < min_gx ? min_gx : 0);
+                pivot_y = touch->y0 - page->g.y + (page->g.y < min_gy ? min_gy : 0);
+                x0 = touch->x0;
+                y0 = touch->y0;
+
+                scroll_x = page->opt & EVE_PAGE_OPT_SCROLL_X;
+                scroll_y = page->opt & EVE_PAGE_OPT_SCROLL_Y;
+                if (!scroll_x) pivot_x = x0;
+                if (!scroll_y) pivot_y = y0;
+
+                eve_window_scroll(window, &scroll_tag);
+                start = eve_phy_lho_start(lho, pivot_x, pivot_y, x0, y0, eve_get_tick());
+                if (start) {
+                    eve_vtrack_start(lho, eve_phy_lho_tick, EVE_TOUCH_TIMEOUT_TRACK, touch, scroll_tag);
                 }
             }
+        }
 
-            if (!eve_timer_running()) {
-                int _ret = 0;
-
-                switch (page->track_mode) {
-                    case PAGE_TMODE_SCROLL: {
-                        page->track_mode = PAGE_TMODE_NONE;
-                        eve_window_scroll_stop(window);
-                        _ret = eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_SCROLL_STOP, touch, evt, tag0);
-                        break;
-                    }
-
-                    case PAGE_TMODE_TRACK: {
-                        page->track_mode = PAGE_TMODE_NONE;
-                        _ret = eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_TRACK_STOP, touch, evt, tag0);
-                        break;
-                    }
+        if (!start) {
+            switch (page->track_mode) {
+                case PAGE_TMODE_SCROLL: {
+                    page->track_mode = PAGE_TMODE_NONE;
+                    eve_window_scroll_stop(window);
+                    eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_SCROLL_STOP, touch, evt);
+                    break;
                 }
-                if (_ret) return _ret;
-            }
-            ret = 1;
-        }
 
-        if ((evt & EVE_TOUCH_ETYPE_TRACK) && (page->track_mode == PAGE_TMODE_SCROLL)) {
-            if (scroll_x) {
-                page->g.x = page->x0 + touch->x0 - touch->x;
-            }
-            if (scroll_y) {
-                page->g.y = page->y0 + touch->y0 - touch->y;
+                case PAGE_TMODE_TRACK: {
+                    page->track_mode = PAGE_TMODE_NONE;
+                    eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_TRACK_STOP, touch, evt);
+                    break;
+                }
             }
-            ret = 1;
-        }
-    } else if ((evt & EVE_TOUCH_ETYPE_TIMER) && (page->track_mode == PAGE_TMODE_SCROLL) && (page->opt & EVE_PAGE_OPT_SCROLL_BACK)) {
-        EVEPhyLHO *lho = &page->lho;
-        int scroll_x = page->opt & EVE_PAGE_OPT_SCROLL_X;
-        int scroll_y = page->opt & EVE_PAGE_OPT_SCROLL_Y;
-        int x, y, more;
-
-        more = eve_phy_lho_tick(lho, eve_get_tick() - page->lho_t0, scroll_x ? &x : NULL, scroll_y ? &y : NULL);
-        if (scroll_x) page->g.x = x;
-        if (scroll_y) page->g.y = y;
-        if (!more) {
-            int _ret = 0;
-
-            page->track_mode = PAGE_TMODE_NONE;
-            eve_timer_stop();
-            eve_window_scroll_stop(window);
-            _ret = eve_view_uievt_push_gest(view, EVE_UIEVT_GEST_SCROLL_STOP, touch, evt, tag0);
-            if (_ret) return _ret;
+            if (eve_window_dirty(window)) return 1;
         }
-        ret = 1;
+        rv = 1;
     }
 
-    return ret;
+    return rv;
 }
 
 uint8_t eve_page_draw(EVEPage *page, uint8_t tag0) {
     EVEView *view = &page->v;
     EVEWidget *widget = page->widget;
     int i;
-    uint8_t tagN = tag0;
+    uint8_t tagN;
     uint8_t tag_opt;
 
-    tag_opt = EVE_TOUCH_OPT_TRACK | EVE_TOUCH_OPT_TRACK_XY;
+    tag_opt = EVE_TOUCH_OPT_TRACK_XY;
     if (page->opt & EVE_PAGE_OPT_TRACK_EXT_X) tag_opt |= EVE_TOUCH_OPT_TRACK_EXT_X;
     if (page->opt & EVE_PAGE_OPT_TRACK_EXT_Y) tag_opt |= EVE_TOUCH_OPT_TRACK_EXT_Y;
 
@@ -354,52 +402,41 @@ draw_nextw:
     eve_cmd_dl(RESTORE_CONTEXT());
 
     for (i=tag0; i<tagN; i++) {
-        if (i != EVE_NOTAG) eve_touch_set_opt(i, eve_touch_get_opt(i) | tag_opt);
+        if (i != EVE_NOTAG) eve_tag_set_opt(i, eve_tag_get_opt(i) | tag_opt);
     }
 
     return tagN;
 }
 
-int eve_page_touch(EVEPage *page, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+int eve_page_touch(EVEPage *page, EVETouch *touch, uint16_t evt) {
     EVEWidget *widget = page->widget;
-    EVEViewStack *stack = page->stack;
+    EVEWindow *window = page->v.window;
     int8_t touch_idx = eve_touch_get_idx(touch);
     uint16_t _evt;
-    int i, ret;
+    int i, rv;
 
     if (touch_idx > 0) return 0;
 
-    _evt = eve_touch_evt(touch, evt, tag0, page->v.tag, 1);
+    _evt = eve_touch_evt(touch, evt, page->v.tag, 1);
     if (_evt) {
-        ret = page_touch(page, touch, _evt, tag0);
-        if (stack->dirty) {
-            stack->dirty = 0;
-            return 1;
-        }
-        if (ret) return 1;
+        rv = page_touch(page, touch, _evt);
+        if (rv || eve_window_dirty(window)) return 1;
     }
     for (i=0; i<page->widget_size; i++) {
         if (!eve_page_rect_visible(page, &widget->g) || (widget->flags & (EVE_WIDGET_FLAG_SKIP | EVE_WIDGET_FLAG_RO | EVE_WIDGET_FLAG_HIDDEN))) goto touch_nextw;
 
-        _evt = eve_touch_evt(touch, evt, tag0, widget->tag0, widget->tagN - widget->tag0);
+        _evt = eve_touch_evt(touch, evt, widget->tag0, widget->tagN - widget->tag0);
         if (_evt) {
             if (page->track_mode == PAGE_TMODE_NONE) {
-                ret = widget->touch(widget, touch, _evt);
-                if (stack->dirty) {
-                    stack->dirty = 0;
+                rv = widget->touch(widget, touch, _evt);
+                if (eve_window_dirty(window)) return 1;
+                if (rv) {
+                    eve_page_set_focus(page, widget);
                     return 1;
                 }
-                if (ret) {
-                    eve_widget_set_focus(widget);
-                    return 1;
-                }
-            }
-            ret = page_touch(page, touch, _evt, tag0);
-            if (stack->dirty) {
-                stack->dirty = 0;
-                return 1;
             }
-            if (ret) return 1;
+            rv = page_touch(page, touch, _evt);
+            if (rv || eve_window_dirty(window)) return 1;
         }
 
 touch_nextw:
diff --git a/fw/fe310/eos/eve/screen/page.h b/fw/fe310/eos/eve/screen/page.h
index 6874a2d..067565b 100644
--- a/fw/fe310/eos/eve/screen/page.h
+++ b/fw/fe310/eos/eve/screen/page.h
@@ -1,7 +1,5 @@
 #include <stdint.h>
 
-#define EVE_PAGE_KBDCH_CLOSE        0x1a
-
 #define EVE_PAGE_OPT_SCROLL_X       0x01
 #define EVE_PAGE_OPT_SCROLL_Y       0x02
 #define EVE_PAGE_OPT_SCROLL_BACK    0x04
@@ -15,8 +13,8 @@ struct EVEWidget;
 struct EVEPage;
 
 typedef uint8_t (*eve_page_draw_t) (struct EVEPage *, uint8_t);
-typedef int (*eve_page_touch_t) (struct EVEPage *, EVETouch *, uint16_t, uint8_t);
-typedef int (*eve_page_uievt_t) (struct EVEPage *, uint16_t, void *);
+typedef int (*eve_page_touch_t) (struct EVEPage *, EVETouch *, uint16_t);
+typedef void (*eve_page_uievt_t) (struct EVEPage *, uint16_t, void *);
 typedef void (*eve_page_destructor_t) (struct EVEPage *);
 
 typedef struct EVEPage {
@@ -24,19 +22,23 @@ typedef struct EVEPage {
     EVERect g;
     int16_t x0;
     int16_t y0;
-    EVEViewStack *stack;
+    EVEVStack *stack;
     eve_page_destructor_t destructor;
     struct EVEWidget *widget;
     uint16_t widget_size;
     struct EVEWidget *widget_f;
     EVEPhyLHO lho;
-    uint32_t lho_t0;
     uint8_t track_mode;
     uint8_t opt;
 } EVEPage;
 
-void eve_page_init(EVEPage *page, EVEWindow *window, EVEViewStack *stack, struct EVEWidget *widget, uint16_t widget_size, uint8_t opt, eve_page_draw_t draw, eve_page_touch_t touch, eve_page_uievt_t uievt, eve_page_destructor_t destructor);
+void eve_page_init(EVEPage *page, EVEWindow *window, EVEVStack *stack, struct EVEWidget *widget, uint16_t widget_size, uint8_t opt, eve_page_draw_t draw, eve_page_touch_t touch, eve_page_uievt_t uievt, eve_page_destructor_t destructor);
+void eve_page_attach(EVEPage *page, EVEWindow *window, void *page_id);
+void eve_page_detach(EVEPage *page);
+void eve_page_set_param(EVEPage *page, void *param);
 
+EVEView *eve_page_view(EVEPage *page);
+EVEPage *eve_page_from_view(EVEView *view);
 struct EVEWidget *eve_page_widget(EVEPage *page, uint16_t idx);
 struct EVEWidget *eve_page_widget_search(EVEPage *page, char *label);
 void eve_page_set_widget(EVEPage *page, struct EVEWidget *widget, uint16_t widget_size);
@@ -53,12 +55,12 @@ int16_t eve_page_win_y(EVEPage *page, int16_t y);
 /* Page to screen coordinates */
 int16_t eve_page_scr_x(EVEPage *page, int16_t x);
 int16_t eve_page_scr_y(EVEPage *page, int16_t y);
-int eve_page_rect_visible(EVEPage *page, EVERect *g);
+int eve_page_rect_visible(EVEPage *page, EVERect *rect);
 void eve_page_show_rect(EVEPage *page, EVERect *rect);
-int eve_page_oob(EVEPage *page, int *_max_x, int *_max_y);
+int eve_page_oob(EVEPage *page, int *min_x, int *min_y);
 
 struct EVEWidget *eve_page_focus(EVEPage *page);
 void eve_page_set_focus(EVEPage *page, struct EVEWidget *widget);
 
 uint8_t eve_page_draw(EVEPage *page, uint8_t tag0);
-int eve_page_touch(EVEPage *page, EVETouch *touch, uint16_t evt, uint8_t tag0);
+int eve_page_touch(EVEPage *page, EVETouch *touch, uint16_t evt);
diff --git a/fw/fe310/eos/eve/screen/uievt.h b/fw/fe310/eos/eve/screen/uievt.h
index 8e1e682..e40624a 100644
--- a/fw/fe310/eos/eve/screen/uievt.h
+++ b/fw/fe310/eos/eve/screen/uievt.h
@@ -5,12 +5,12 @@
 #define EVE_UIEVT_GEST_TRACK_STOP       5
 #define EVE_UIEVT_WIN_UPDATE_G          6
 #define EVE_UIEVT_PAGE_UPDATE_G         7
-#define EVE_UIEVT_WIDGET_UPDATE_G       8
-#define EVE_UIEVT_WIDGET_FOCUS_IN       9
-#define EVE_UIEVT_WIDGET_FOCUS_OUT      10
+#define EVE_UIEVT_WIDGET_UPDATE         8
+#define EVE_UIEVT_WIDGET_UPDATE_G       9
+#define EVE_UIEVT_WIDGET_FOCUS_IN       10
+#define EVE_UIEVT_WIDGET_FOCUS_OUT      11
 
 typedef struct EVEUIEvtTouch {
     EVETouch *touch;
     uint16_t evt;
-    uint8_t tag0;
 } EVEUIEvtTouch;
diff --git a/fw/fe310/eos/eve/screen/view.c b/fw/fe310/eos/eve/screen/view.c
index d6e9ede..a1290f0 100644
--- a/fw/fe310/eos/eve/screen/view.c
+++ b/fw/fe310/eos/eve/screen/view.c
@@ -15,7 +15,19 @@ void eve_view_init(EVEView *view, EVEWindow *window, eve_view_draw_t draw, eve_v
     view->window = window;
     view->color_bg = 0x000000;
     view->color_fg = 0xffffff;
-    window->view = view;
+}
+
+void eve_view_attach(EVEView *view, EVEWindow *window, void *view_id) {
+    view->window = window;
+    eve_window_attach_view(window, view, view_id);
+}
+
+void eve_view_detach(EVEView *view) {
+    eve_window_detach_view(view->window);
+}
+
+void eve_view_set_param(EVEView *view, void *param) {
+    view->param = param;
 }
 
 void eve_view_set_color_bg(EVEView *view, uint8_t r, uint8_t g, uint8_t b) {
@@ -29,78 +41,121 @@ void eve_view_set_color_fg(EVEView *view, uint8_t r, uint8_t g, uint8_t b) {
 uint8_t eve_view_clear(EVEView *view, uint8_t tag0, uint8_t tag_opt) {
     EVEWindow *win_scroll = NULL;
     EVEWindow *window = view->window;
-    uint8_t _tag;
+    uint8_t scroll_tag;
 
-    win_scroll = eve_window_scroll(window->root, &_tag);
+    win_scroll = eve_window_scroll(window, &scroll_tag);
     eve_cmd_dl(CLEAR_COLOR_RGBC(view->color_bg));
     eve_cmd_dl(COLOR_RGBC(view->color_fg));
     if (win_scroll == window) {
-        view->tag = _tag;
-        eve_touch_set_opt(view->tag, tag_opt);
-        eve_cmd_dl(TAG(view->tag));
-        eve_cmd_dl(CLEAR_TAG(view->tag));
+        view->tag = scroll_tag;
     } else if (win_scroll) {
         view->tag = EVE_NOTAG;
-        eve_cmd_dl(TAG(view->tag));
-        eve_cmd_dl(CLEAR_TAG(view->tag));
     } else {
         view->tag = tag0;
         if (tag0 != EVE_NOTAG) {
-            eve_touch_set_opt(tag0, tag_opt);
-            eve_cmd_dl(CLEAR_TAG(tag0));
+            eve_tag_set_opt(tag0, tag_opt);
             tag0++;
         }
     }
+    eve_cmd_dl(CLEAR_TAG(view->tag));
     eve_cmd_dl(CLEAR(1,1,1));
     return tag0;
 }
 
-int eve_view_uievt_push(EVEView *view, uint16_t evt, void *param) {
-    if (view->uievt) return view->uievt(view, evt, param);
-    return 0;
+uint8_t eve_view_tag(EVEView *view, uint8_t tag, uint8_t tag_opt) {
+    if (tag != EVE_NOTAG) {
+        eve_tag_set_opt(tag, tag_opt);
+        eve_cmd_dl(TAG(tag));
+        tag++;
+    }
+    return tag;
 }
 
-int eve_view_uievt_push_gest(EVEView *view, uint16_t evt, EVETouch *touch, uint16_t t_evt, uint8_t tag0) {
-    if (view->uievt) {
-        EVEUIEvtTouch param;
+void eve_view_uievt_push(EVEView *view, uint16_t evt, void *param) {
+    if (view->uievt) view->uievt(view, evt, param);
+}
 
-        param.touch = touch;
-        param.evt = t_evt;
-        param.tag0 = tag0;
-        return view->uievt(view, evt, &param);
-    }
-    return 0;
+void eve_view_uievt_push_gest(EVEView *view, uint16_t evt, EVETouch *touch, uint16_t t_evt) {
+    EVEUIEvtTouch param;
+
+    if (view->uievt == NULL) return;
+
+    param.touch = touch;
+    param.evt = t_evt;
+    view->uievt(view, evt, &param);
 }
 
-void eve_stack_init(EVEViewStack *stack) {
-    memset(stack, 0, sizeof(EVEViewStack));
+void eve_vstack_init(EVEVStack *stack) {
+    memset(stack, 0, sizeof(EVEVStack));
 }
 
-void eve_stack_create_view(EVEViewStack *stack, EVEWindow *window, eve_view_constructor_t constructor) {
-    int rv;
+int eve_vstack_push(EVEVStack *stack, eve_view_constructor_t constructor) {
+    if (stack->level == EVE_VIEW_SIZE_STACK) return EVE_ERR_FULL;
 
-    stack->dirty = 1;
-    if (stack->level < EVE_VIEW_SIZE_STACK - 1) {
-        stack->constructor[stack->level] = constructor;
-        stack->level++;
-        rv = constructor(window, stack);
-        if (rv) eve_stack_back(stack, window);
-    }
+    stack->constructor[stack->level] = constructor;
+    stack->level++;
+
+    return EVE_OK;
 }
 
-void eve_stack_back(EVEViewStack *stack, EVEWindow *window) {
+eve_view_constructor_t eve_vstack_pull(EVEVStack *stack) {
     eve_view_constructor_t constructor;
-    int rv = 1;
 
-    stack->dirty = 1;
-    while ((stack->level > 1) && rv) {
+    constructor = eve_vstack_get(stack);
+    if (stack->level) {
         stack->level--;
-        constructor = stack->constructor[stack->level - 1];
-        rv = constructor(window, stack);
+        stack->constructor[stack->level] = NULL;
     }
+    return constructor;
 }
 
-eve_view_constructor_t eve_stack_get(EVEViewStack *stack) {
+eve_view_constructor_t eve_vstack_get(EVEVStack *stack) {
     if (stack->level) return stack->constructor[stack->level - 1];
     return NULL;
 }
+
+int eve_vstack_empty(EVEVStack *stack) {
+    return (stack->level == 0);
+}
+
+int eve_vstack_full(EVEVStack *stack) {
+    return (stack->level == EVE_VIEW_SIZE_STACK);
+}
+
+int eve_vstack_level(EVEVStack *stack) {
+    return stack->level;
+}
+
+int eve_vstack_create_view(EVEVStack *stack, EVEWindow *window, eve_view_constructor_t constructor) {
+    EVEView *view;
+    int rv;
+
+    rv = eve_vstack_push(stack, constructor);
+    if (rv) return rv;
+
+    view = constructor(window, stack);
+    if (view == NULL) {
+        eve_vstack_pull(stack);
+        return EVE_ERR;
+    }
+
+    eve_view_attach(view, window, constructor);
+
+    return EVE_OK;
+}
+
+int eve_vstack_back(EVEVStack *stack, EVEWindow *window) {
+    EVEView *view;
+    eve_view_constructor_t constructor;
+
+    eve_vstack_pull(stack);
+    constructor = eve_vstack_get(stack);
+    if (constructor == NULL) return EVE_ERR_EMPTY;
+
+    view = constructor(window, stack);
+    if (view == NULL) return EVE_ERR;
+
+    eve_view_attach(view, window, constructor);
+
+    return EVE_OK;
+}
diff --git a/fw/fe310/eos/eve/screen/view.h b/fw/fe310/eos/eve/screen/view.h
index 3e8c0a0..c40a620 100644
--- a/fw/fe310/eos/eve/screen/view.h
+++ b/fw/fe310/eos/eve/screen/view.h
@@ -5,13 +5,13 @@
 #define EVE_VIEW_SIZE_STACK             16
 
 struct EVEView;
-struct EVEViewStack;
+struct EVEVStack;
 struct EVEWindow;
 
 typedef uint8_t (*eve_view_draw_t) (struct EVEView *, uint8_t);
-typedef int (*eve_view_touch_t) (struct EVEView *, EVETouch *, uint16_t, uint8_t);
-typedef int (*eve_view_uievt_t) (struct EVEView *, uint16_t, void *);
-typedef int (*eve_view_constructor_t) (struct EVEWindow *window, struct EVEViewStack *);
+typedef int (*eve_view_touch_t) (struct EVEView *, EVETouch *, uint16_t);
+typedef void (*eve_view_uievt_t) (struct EVEView *, uint16_t, void *);
+typedef struct EVEView *(*eve_view_constructor_t) (struct EVEWindow *window, struct EVEVStack *);
 
 typedef struct EVEView {
     eve_view_draw_t draw;
@@ -24,21 +24,29 @@ typedef struct EVEView {
     uint8_t tag;
 } EVEView;
 
-typedef struct EVEViewStack {
+typedef struct EVEVStack {
     eve_view_constructor_t constructor[EVE_VIEW_SIZE_STACK];
     uint8_t level;
-    uint8_t dirty;
-} EVEViewStack;
+} EVEVStack;
 
 void eve_view_init(EVEView *view, struct EVEWindow *window, eve_view_draw_t draw, eve_view_touch_t touch, eve_view_uievt_t uievt, void *param);
+void eve_view_attach(EVEView *view, struct EVEWindow *window, void *view_id);
+void eve_view_detach(EVEView *view);
+void eve_view_set_param(EVEView *view, void *param);
 void eve_view_set_color_bg(EVEView *view, uint8_t r, uint8_t g, uint8_t b);
 void eve_view_set_color_fg(EVEView *view, uint8_t r, uint8_t g, uint8_t b);
 uint8_t eve_view_clear(EVEView *view, uint8_t tag0, uint8_t tag_opt);
-
-int eve_view_uievt_push(EVEView *view, uint16_t evt, void *param);
-int eve_view_uievt_push_gest(EVEView *view, uint16_t evt, EVETouch *touch, uint16_t t_evt, uint8_t tag0);
-
-void eve_stack_init(EVEViewStack *stack);
-void eve_stack_create_view(EVEViewStack *stack, struct EVEWindow *window, eve_view_constructor_t constructor);
-void eve_stack_back(EVEViewStack *stack, struct EVEWindow *window);
-eve_view_constructor_t eve_stack_get(EVEViewStack *stack);
\ No newline at end of file
+uint8_t eve_view_tag(EVEView *view, uint8_t tag, uint8_t tag_opt);
+
+void eve_view_uievt_push(EVEView *view, uint16_t evt, void *param);
+void eve_view_uievt_push_gest(EVEView *view, uint16_t evt, EVETouch *touch, uint16_t t_evt);
+
+void eve_vstack_init(EVEVStack *stack);
+int eve_vstack_push(EVEVStack *stack, eve_view_constructor_t constructor);
+eve_view_constructor_t eve_vstack_pull(EVEVStack *stack);
+eve_view_constructor_t eve_vstack_get(EVEVStack *stack);
+int eve_vstack_empty(EVEVStack *stack);
+int eve_vstack_full(EVEVStack *stack);
+int eve_vstack_level(EVEVStack *stack);
+int eve_vstack_create_view(EVEVStack *stack, struct EVEWindow *window, eve_view_constructor_t constructor);
+int eve_vstack_back(EVEVStack *stack, struct EVEWindow *window);
diff --git a/fw/fe310/eos/eve/screen/window.c b/fw/fe310/eos/eve/screen/window.c
index 34d265a..90f4e20 100644
--- a/fw/fe310/eos/eve/screen/window.c
+++ b/fw/fe310/eos/eve/screen/window.c
@@ -1,6 +1,5 @@
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 
 #include "eve.h"
 #include "eve_kbd.h"
@@ -28,7 +27,7 @@ void eve_window_init_root(EVEWindowRoot *root, EVERect *g, char *name, EVEFont *
     root->font = font;
     root->win_kbd = NULL;
     root->win_scroll = NULL;
-    root->tag0 = EVE_NOTAG;
+    root->tag_scroll = EVE_NOTAG;
     eve_touch_set_handler(eve_window_root_touch, root);
 }
 
@@ -41,10 +40,10 @@ static uint8_t kbd_draw(EVEView *view, uint8_t tag0) {
     return tag0;
 }
 
-static int kbd_touch(EVEView *view, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+static int kbd_touch(EVEView *view, EVETouch *touch, uint16_t evt) {
     EVEKbd *kbd = view->param;
 
-    return eve_kbd_touch(kbd, touch, evt, tag0);
+    return eve_kbd_touch(kbd, touch, evt);
 }
 
 void eve_window_init_kbd(EVEWindowKbd *win_kbd, EVERect *g, EVEWindowRoot *root, char *name, EVEKbd *kbd) {
@@ -55,6 +54,7 @@ void eve_window_init_kbd(EVEWindowKbd *win_kbd, EVERect *g, EVEWindowRoot *root,
     win_kbd->kbd = kbd;
     root->win_kbd = win_kbd;
     eve_view_init(&win_kbd->v, _window, kbd_draw, kbd_touch, NULL, kbd);
+    eve_view_attach(&win_kbd->v, _window, NULL);
 }
 
 void eve_window_set_parent(EVEWindow *window, EVEWindow *parent) {
@@ -62,6 +62,26 @@ void eve_window_set_parent(EVEWindow *window, EVEWindow *parent) {
     window->root = parent->root;
 }
 
+void eve_window_attach_view(EVEWindow *window, EVEView *view, void *view_id) {
+    if (window->view) window->dirty = 1;
+    window->view = view;
+    window->view_id = view_id;
+}
+
+void eve_window_detach_view(EVEWindow *window) {
+    if (window->view) window->dirty = 1;
+    window->view = NULL;
+    window->view_id = NULL;
+}
+
+int eve_window_dirty(EVEWindow *window) {
+    return window->dirty;
+}
+
+void eve_window_clean(EVEWindow *window) {
+    window->dirty = 0;
+}
+
 int eve_window_visible(EVEWindow *window) {
     if (window->g.x >= window->root->w.g.w) return 0;
     if (window->g.y >= window->root->w.g.h) return 0;
@@ -70,31 +90,32 @@ int eve_window_visible(EVEWindow *window) {
     return 1;
 }
 
-static void window_visible_g(EVEWindow *w, EVERect *g) {
-    while (w) {
-        if (eve_window_visible(w)) {
-            if (w->g.x > g->x) g->w = MIN(g->w, w->g.x - g->x);
-            if (w->g.y > g->y) g->h = MIN(g->h, w->g.y - g->y);
-            if (w->g.x + w->g.w < g->x + g->w) {
-                uint16_t x0 = g->w - MIN(g->w, (g->x + g->w) - (w->g.x + w->g.w));
-                g->x += x0;
-                g->w -= x0;
+static void window_visible_g(EVEWindow *win, EVERect *rect) {
+    while (win) {
+        if (eve_window_visible(win)) {
+            if (win->g.x > rect->x) rect->w = MIN(rect->w, win->g.x - rect->x);
+            if (win->g.y > rect->y) rect->h = MIN(rect->h, win->g.y - rect->y);
+            if (win->g.x + win->g.w < rect->x + rect->w) {
+                uint16_t x0 = rect->w - MIN(rect->w, (rect->x + rect->w) - (win->g.x + win->g.w));
+                rect->x += x0;
+                rect->w -= x0;
             }
-            if (w->g.y + w->g.h < g->y + g->h) {
-                uint16_t y0 = g->h - MIN(g->h, (g->y + g->h) - (w->g.y + w->g.h));
-                g->y += y0;
-                g->h -= y0;
+            if (win->g.y + win->g.h < rect->y + rect->h) {
+                uint16_t y0 = rect->h - MIN(rect->h, (rect->y + rect->h) - (win->g.y + win->g.h));
+                rect->y += y0;
+                rect->h -= y0;
             }
+            if ((rect->w == 0) || (rect->h == 0)) return;
         }
-        if (w->child_head) window_visible_g(w->child_head, g);
-        w = w->next;
+        if (win->child_head) window_visible_g(win->child_head, rect);
+        win = win->next;
     }
 }
 
-void eve_window_visible_g(EVEWindow *window, EVERect *g) {
-    *g = window->g;
-    if (window->child_head) window_visible_g(window->child_head, g);
-    window_visible_g(window->next, g);
+void eve_window_visible_g(EVEWindow *window, EVERect *rect) {
+    *rect = window->g;
+    if (window->child_head) window_visible_g(window->child_head, rect);
+    window_visible_g(window->next, rect);
 }
 
 void eve_window_append(EVEWindow *window) {
@@ -160,8 +181,8 @@ EVEWindow *eve_window_search(EVEWindow *window, char *name) {
     while (window) {
         if (window->name && (strcmp(name, window->name) == 0)) return window;
         if (window->child_head) {
-            EVEWindow *ret = eve_window_search(window->child_head, name);
-            if (ret) return ret;
+            EVEWindow *rv = eve_window_search(window->child_head, name);
+            if (rv) return rv;
         }
         window = window->next;
     }
@@ -198,17 +219,18 @@ uint8_t eve_window_draw(EVEWindow *window, uint8_t tag0) {
     return tag0;
 }
 
-int eve_window_touch(EVEWindow *window, EVETouch *touch, uint16_t evt, uint8_t tag0) {
-    int ret = 0;
+int eve_window_touch(EVEWindow *window, EVETouch *touch, uint16_t evt) {
+    int rv = 0;
 
     while (window) {
         if (window->child_tail) {
-            ret = eve_window_touch(window->child_tail, touch, evt, tag0);
-            if (ret) return 1;
+            rv = eve_window_touch(window->child_tail, touch, evt);
+            if (rv) return 1;
         }
         if (eve_window_visible(window) && window->view) {
-            ret = window->view->touch(window->view, touch, evt, tag0);
-            if (ret) return 1;
+            rv = window->view->touch(window->view, touch, evt);
+            window->dirty = 0;
+            if (rv) return 1;
         }
         window = window->prev;
     }
@@ -223,24 +245,31 @@ void eve_window_root_draw(EVEWindowRoot *root) {
     eve_cmd_burst_start();
     eve_cmd_dl(CMD_DLSTART);
 
-    if (root->tag0 != EVE_NOTAG) tag0 = EVE_NOTAG;
+    if (root->tag_scroll != EVE_NOTAG) tag0 = EVE_NOTAG;
     eve_window_draw(&root->w, tag0);
 
     eve_cmd_dl(DISPLAY());
     eve_cmd_dl(CMD_SWAP);
     eve_cmd_burst_end();
     rv = eve_cmd_exec(1);
-    if (rv) printf("EVE EXEC ERR\n");
+    if (rv) EVE_LOG(EVE_LOG_ERR, "EVE CMD EXEC ERR:%d\n", rv);
 }
 
-void eve_window_root_touch(EVETouch *touch, uint16_t evt, uint8_t tag0, void *win) {
+void eve_window_root_touch(EVETouch *touch, uint16_t evt, void *win) {
     EVEWindowRoot *root = (EVEWindowRoot *)win;
-    int ret;
+    int rv;
 
-    if (root->tag0 != EVE_NOTAG) tag0 = root->tag0;
-    ret = eve_window_touch(&root->w, touch, evt, tag0);
-    if (ret) {
-        eve_touch_clear_opt();
+    rv = eve_window_touch(&root->w, touch, evt);
+    if (rv) {
+        uint8_t tag_opt = 0;
+
+        if (root->tag_scroll != EVE_NOTAG) {
+            tag_opt = eve_tag_get_opt(root->tag_scroll);
+        }
+        eve_tag_clear_opt();
+        if (root->tag_scroll != EVE_NOTAG) {
+            eve_tag_set_opt(root->tag_scroll, tag_opt);
+        }
         eve_window_root_draw(root);
     }
 }
@@ -275,14 +304,10 @@ void eve_window_kbd_detach(EVEWindow *window) {
     }
 }
 
-EVEFont *eve_window_font(EVEWindow *window) {
+EVEWindow *eve_window_scroll(EVEWindow *window, uint8_t *tag) {
     EVEWindowRoot *root = window->root;
 
-    return root->font;
-}
-
-EVEWindow *eve_window_scroll(EVEWindowRoot *root, uint8_t *tag) {
-    if (tag) *tag = root->tag0;
+    if (tag) *tag = root->tag_scroll;
     return root->win_scroll;
 }
 
@@ -290,12 +315,18 @@ void eve_window_scroll_start(EVEWindow *window, uint8_t tag) {
     EVEWindowRoot *root = window->root;
 
     root->win_scroll = window;
-    root->tag0 = tag;
+    root->tag_scroll = tag;
 }
 
 void eve_window_scroll_stop(EVEWindow *window) {
     EVEWindowRoot *root = window->root;
 
     root->win_scroll = NULL;
-    root->tag0 = EVE_NOTAG;
+    root->tag_scroll = EVE_NOTAG;
+}
+
+EVEFont *eve_window_font(EVEWindow *window) {
+    EVEWindowRoot *root = window->root;
+
+    return root->font;
 }
diff --git a/fw/fe310/eos/eve/screen/window.h b/fw/fe310/eos/eve/screen/window.h
index 27465c4..ac52fb8 100644
--- a/fw/fe310/eos/eve/screen/window.h
+++ b/fw/fe310/eos/eve/screen/window.h
@@ -8,12 +8,14 @@ typedef struct EVEWindow {
     EVERect g;
     char *name;
     EVEView *view;
+    void *view_id;
     struct EVEWindowRoot *root;
     struct EVEWindow *parent;
     struct EVEWindow *next;
     struct EVEWindow *prev;
     struct EVEWindow *child_head;
     struct EVEWindow *child_tail;
+    int dirty;
 } EVEWindow;
 
 typedef struct EVEWindowKbd {
@@ -28,7 +30,7 @@ typedef struct EVEWindowRoot {
     EVEFont *font;
     EVEWindowKbd *win_kbd;
     EVEWindow *win_scroll;
-    uint8_t tag0;
+    uint8_t tag_scroll;
 } EVEWindowRoot;
 
 void eve_window_init(EVEWindow *window, EVERect *g, EVEWindow *parent, char *name);
@@ -36,8 +38,13 @@ void eve_window_init_root(EVEWindowRoot *root, EVERect *g, char *name, EVEFont *
 void eve_window_init_kbd(EVEWindowKbd *win_kbd, EVERect *g, EVEWindowRoot *root, char *name, EVEKbd *kbd);
 void eve_window_set_parent(EVEWindow *window, EVEWindow *parent);
 
+void eve_window_attach_view(EVEWindow *window, EVEView *view, void *view_id);
+void eve_window_detach_view(EVEWindow *window);
+int eve_window_dirty(EVEWindow *window);
+void eve_window_clean(EVEWindow *window);
+
 int eve_window_visible(EVEWindow *window);
-void eve_window_visible_g(EVEWindow *window, EVERect *g);
+void eve_window_visible_g(EVEWindow *window, EVERect *rect);
 
 void eve_window_append(EVEWindow *window);
 void eve_window_insert_above(EVEWindow *window, EVEWindow *win_prev);
@@ -46,15 +53,16 @@ void eve_window_remove(EVEWindow *window);
 EVEWindow *eve_window_search(EVEWindow *window, char *name);
 
 uint8_t eve_window_draw(EVEWindow *window, uint8_t tag0);
-int eve_window_touch(EVEWindow *window, EVETouch *touch, uint16_t evt, uint8_t tag0);
+int eve_window_touch(EVEWindow *window, EVETouch *touch, uint16_t evt);
 void eve_window_root_draw(EVEWindowRoot *root);
-void eve_window_root_touch(EVETouch *touch, uint16_t evt, uint8_t tag0, void *win);
+void eve_window_root_touch(EVETouch *touch, uint16_t evt, void *win);
 
 EVEKbd *eve_window_kbd(EVEWindow *window);
 void eve_window_kbd_attach(EVEWindow *window);
 void eve_window_kbd_detach(EVEWindow *window);
-EVEFont *eve_window_font(EVEWindow *window);
 
-EVEWindow *eve_window_scroll(EVEWindowRoot *root, uint8_t *tag);
+EVEWindow *eve_window_scroll(EVEWindow *window, uint8_t *tag);
 void eve_window_scroll_start(EVEWindow *window, uint8_t tag);
 void eve_window_scroll_stop(EVEWindow *window);
+
+EVEFont *eve_window_font(EVEWindow *window);