Rework/recode e_kbd stuff. This makes keyboard work nicely with everything

that I have tested so far. No more initial home window size problems either :)

SVN revision: 44728

diff --git a/src/modules/illume2/e_kbd.c b/src/modules/illume2/e_kbd.c
index 20b7489..9426324 100644 (file)
--- a/src/modules/illume2/e_kbd.c
+++ b/src/modules/illume2/e_kbd.c
@@ -7,36 +7,37 @@
 
 /* local function prototypes */
 static void _e_kbd_cb_free(E_Kbd *kbd);
-static int _e_kbd_cb_delay_hide(void *data);
-static void _e_kbd_hide(E_Kbd *kbd);
+static int _e_kbd_cb_delayed_hide(void *data);
+static int _e_kbd_cb_animate(void *data);
+static E_Kbd *_e_kbd_by_border_get(E_Border *bd);
 static void _e_kbd_layout_send(E_Kbd *kbd);
 static void _e_kbd_border_show(E_Border *bd);
 static void _e_kbd_border_hide(E_Border *bd);
+static void _e_kbd_border_adopt(E_Kbd *kbd, E_Border *bd);
+static int _e_kbd_border_is_keyboard(E_Border *bd);
+static void _e_kbd_hide(E_Kbd *kbd);
 static void _e_kbd_slide(E_Kbd *kbd, int visible, double len);
 static void _e_kbd_all_show(void);
 static void _e_kbd_all_hide(void);
 static void _e_kbd_all_toggle(void);
 static void _e_kbd_all_layout_set(E_Kbd_Layout layout);
-static E_Kbd *_e_kbd_by_border_get(E_Border *bd);
-static void _e_kbd_border_adopt(E_Kbd *kbd, E_Border *bd);
-static void _e_kbd_vkbd_state_handle(Ecore_X_Virtual_Keyboard_State state);
-static int _e_kbd_border_is_keyboard(E_Border *bd);
 
-static int _e_kbd_cb_animate(void *data);
+/* handlers */
 static int _e_kbd_cb_client_message(void *data, int type, void *event);
 static int _e_kbd_cb_border_remove(void *data, int type, void *event);
 static int _e_kbd_cb_border_focus_in(void *data, int type, void *event);
 static int _e_kbd_cb_border_focus_out(void *data, int type, void *event);
 static int _e_kbd_cb_border_property(void *data, int type, void *event);
+
+/* hooks */
 static void _e_kbd_cb_border_pre_post_fetch(void *data, void *data2);
-static void _e_kbd_cb_border_post_assign(void *data, void *data2);
-static void _e_kbd_cb_border_end(void *data, void *data2);
+static void _e_kbd_cb_border_post_border_assign(void *data, void *data2);
+static void _e_kbd_cb_border_eval_end(void *data, void *data2);
 
 /* local variables */
-static Eina_List *handlers = NULL, *hooks = NULL, *kbds = NULL;
-static Ecore_X_Atom atom_mb_invoker = 0;
-static Ecore_X_Atom atom_mtp_invoker = 0;
-static Ecore_X_Atom atom_focused_vkbd_state = 0;
+static Eina_List *kbds = NULL, *handlers = NULL, *hooks = NULL;
+static E_Border *focused_border = NULL;
+static Ecore_X_Atom focused_vkbd_state = 0;
 const char *mod_dir = NULL;
 
 /* public functions */
@@ -44,8 +45,6 @@ int
 e_kbd_init(E_Module *m) 
 {
    mod_dir = eina_stringshare_add(m->dir);
-   atom_mb_invoker = ecore_x_atom_get("_MB_IM_INVOKER_COMMAND");
-   atom_mtp_invoker = ecore_x_atom_get("_MTP_IM_INVOKER_COMMAND");
 
    handlers = 
      eina_list_append(handlers, 
@@ -67,36 +66,38 @@ e_kbd_init(E_Module *m)
      eina_list_append(handlers, 
                       ecore_event_handler_add(E_EVENT_BORDER_PROPERTY, 
                                               _e_kbd_cb_border_property, NULL));
+
    hooks = 
      eina_list_append(hooks, 
                       e_border_hook_add(E_BORDER_HOOK_EVAL_PRE_POST_FETCH, 
                                         _e_kbd_cb_border_pre_post_fetch, NULL));
-   hooks = 
-     eina_list_append(hooks, 
-                      e_border_hook_add(E_BORDER_HOOK_EVAL_POST_BORDER_ASSIGN, 
-                                        _e_kbd_cb_border_post_assign, NULL));
-   hooks = 
-     eina_list_append(hooks, 
-                      e_border_hook_add(E_BORDER_HOOK_EVAL_END, 
-                                        _e_kbd_cb_border_end, NULL));
 
    e_kbd_dbus_init();
+
    return 1;
 }
 
 int 
 e_kbd_shutdown(void) 
 {
-   E_Border_Hook *hook;
+   E_Kbd *kbd;
    Ecore_Event_Handler *handler;
+   E_Border_Hook *hook;
 
    e_kbd_dbus_shutdown();
-   EINA_LIST_FREE(hooks, hook)
-     e_border_hook_del(hook);
+
    EINA_LIST_FREE(handlers, handler)
      ecore_event_handler_del(handler);
+
+   EINA_LIST_FREE(hooks, hook)
+     e_border_hook_del(hook);
+
+   EINA_LIST_FREE(kbds, kbd)
+     e_object_del(E_OBJECT(kbd));
+
    if (mod_dir) eina_stringshare_del(mod_dir);
    mod_dir = NULL;
+
    return 1;
 }
 
@@ -108,38 +109,36 @@ e_kbd_new(void)
    kbd = E_OBJECT_ALLOC(E_Kbd, E_KBD_TYPE, _e_kbd_cb_free);
    if (!kbd) return NULL;
    kbds = eina_list_append(kbds, kbd);
-   kbd->layout = ECORE_X_VIRTUAL_KEYBOARD_STATE_ON;
+   kbd->layout = E_KBD_LAYOUT_ALPHA;
    return kbd;
 }
 
 void 
-e_kbd_enable(E_Kbd *kbd) 
+e_kbd_all_enable(void) 
 {
-   if (!kbd->disabled) return;
-   kbd->disabled = 0;
-   if (kbd->visible) 
-     {
-        kbd->visible = 0;
-        e_kbd_show(kbd);
-     }
+   Eina_List *l;
+   E_Kbd *kbd;
+
+   EINA_LIST_FOREACH(kbds, l, kbd)
+     e_kbd_enable(kbd);
 }
 
 void 
-e_kbd_disable(E_Kbd *kbd) 
+e_kbd_all_disable(void) 
 {
-   if (kbd->disabled) return;
-   if (kbd->visible) e_kbd_hide(kbd);
-   kbd->disabled = 1;
+   Eina_List *l;
+   E_Kbd *kbd;
+
+   EINA_LIST_FOREACH(kbds, l, kbd)
+     e_kbd_disable(kbd);
 }
 
 void 
 e_kbd_show(E_Kbd *kbd) 
 {
-   if (kbd->delay_hide) ecore_timer_del(kbd->delay_hide);
-   kbd->delay_hide = NULL;
-   if (kbd->visible) return;
-   kbd->visible = 1;
-   if (kbd->disabled) return;
+   if (kbd->timer) ecore_timer_del(kbd->timer);
+   kbd->timer = NULL;
+   if ((kbd->visible) || (kbd->disabled)) return;
    _e_kbd_layout_send(kbd);
    if (il_cfg->sliding.kbd.duration <= 0) 
      {
@@ -148,13 +147,13 @@ e_kbd_show(E_Kbd *kbd)
              e_border_fx_offset(kbd->border, 0, 0);
              _e_kbd_border_show(kbd->border);
           }
-        kbd->actually_visible = 1;
+        kbd->visible = 1;
      }
    else 
      {
         if (kbd->border) 
           {
-             e_border_fx_offset(kbd->border, 0, kbd->border->h - kbd->adjust);
+             e_border_fx_offset(kbd->border, 0, (kbd->border->h - kbd->adjust));
              _e_kbd_border_show(kbd->border);
           }
         _e_kbd_slide(kbd, 1, (double)il_cfg->sliding.kbd.duration / 1000.0);
@@ -165,83 +164,74 @@ void
 e_kbd_hide(E_Kbd *kbd) 
 {
    if (!kbd->visible) return;
-   kbd->visible = 0;
-   if (!kbd->delay_hide)
-     kbd->delay_hide = ecore_timer_add(0.2, _e_kbd_cb_delay_hide, kbd);
+   if (!kbd->timer)
+     kbd->timer = ecore_timer_add(0.2, _e_kbd_cb_delayed_hide, kbd);
 }
 
 void 
-e_kbd_safe_app_region_get(E_Zone *zone, int *x, int *y, int *w, int *h) 
+e_kbd_enable(E_Kbd *kbd) 
 {
-   Eina_List *l;
-   E_Kbd *kbd;
-
-   if (x) *x = zone->x;
-   if (y) *y = zone->y;
-   if (w) *w = zone->w;
-   if (h) *h = zone->h;
-   EINA_LIST_FOREACH(kbds, l, kbd) 
-     {
-        if ((kbd->border) && (kbd->border->zone == zone)) 
-          {
-             if ((kbd->actually_visible) && 
-                 (!kbd->animator) && (!kbd->disabled)) 
-               {
-                  if (h) 
-                    {
-                       *h -= kbd->border->h;
-                       if (*h < 0) *h = 0;
-                    }
-               }
-             return;
-          }
-     }
+   if (!kbd->disabled) return;
+   kbd->disabled = 0;
+   if (!kbd->visible) e_kbd_show(kbd);
 }
 
 void 
-e_kbd_fullscreen_set(E_Zone *zone, int fullscreen) 
+e_kbd_disable(E_Kbd *kbd) 
 {
-   Eina_List *l;
-   E_Kbd *kbd;
-
-   EINA_LIST_FOREACH(kbds, l, kbd)
-     if ((!!fullscreen) != kbd->fullscreen) 
-       {
-          int layer = 100;
-
-          kbd->fullscreen = fullscreen;
-          if (fullscreen) layer = 250;
-          if (kbd->border->layer != layer)
-            e_border_layer_set(kbd->border, layer);
-       }
+   if (kbd->disabled) return;
+   if (kbd->visible) e_kbd_hide(kbd);
+   kbd->disabled = 1;
 }
 
 void 
 e_kbd_layout_set(E_Kbd *kbd, E_Kbd_Layout layout) 
 {
-   if (kbd->layout == layout) return;
    kbd->layout = layout;
    _e_kbd_layout_send(kbd);
 }
 
 void 
-e_kbd_all_enable(void) 
+e_kbd_fullscreen_set(E_Zone *zone, int fullscreen) 
 {
    Eina_List *l;
    E_Kbd *kbd;
 
    EINA_LIST_FOREACH(kbds, l, kbd)
-     e_kbd_enable(kbd);
+     if ((!!fullscreen) != kbd->fullscreen) 
+       {
+          kbd->fullscreen = fullscreen;
+          if (kbd->fullscreen)
+            e_border_layer_set(kbd->border, 250);
+          else
+            e_border_layer_set(kbd->border, 100);
+       }
 }
 
 void 
-e_kbd_all_disable(void) 
+e_kbd_safe_app_region_get(E_Zone *zone, int *x, int *y, int *w, int *h) 
 {
    Eina_List *l;
    E_Kbd *kbd;
 
-   EINA_LIST_FOREACH(kbds, l, kbd)
-     e_kbd_disable(kbd);
+   if (x) *x = zone->x;
+   if (y) *y = zone->y;
+   if (w) *w = zone->w;
+   if (h) *h = zone->h;
+   EINA_LIST_FOREACH(kbds, l, kbd) 
+     {
+        if (!kbd->border) continue;
+        if (kbd->border->zone != zone) continue;
+        if ((kbd->visible) && (!kbd->animator) && (!kbd->disabled)) 
+          {
+             if (h) 
+               {
+                  *h -= kbd->border->h;
+                  if (*h < 0) *h = 0;
+               }
+          }
+        return;
+     }
 }
 
 /* local functions */
@@ -250,79 +240,114 @@ _e_kbd_cb_free(E_Kbd *kbd)
 {
    E_Border *bd;
 
-   kbds = eina_list_remove(kbds, kbd);
    if (kbd->animator) ecore_animator_del(kbd->animator);
-   if (kbd->delay_hide) ecore_timer_del(kbd->delay_hide);
+   kbd->animator = NULL;
+   if (kbd->timer) ecore_timer_del(kbd->timer);
+   kbd->timer = NULL;
    EINA_LIST_FREE(kbd->waiting_borders, bd)
      bd->stolen = 0;
    E_FREE(kbd);
 }
 
 static int 
-_e_kbd_cb_delay_hide(void *data) 
+_e_kbd_cb_delayed_hide(void *data) 
 {
    E_Kbd *kbd;
 
    if (!(kbd = data)) return 0;
    _e_kbd_hide(kbd);
-   kbd->delay_hide = NULL;
+   kbd->timer = NULL;
    return 0;
 }
 
-static void 
-_e_kbd_hide(E_Kbd *kbd) 
+static int 
+_e_kbd_cb_animate(void *data) 
 {
-   if (kbd->visible) return;
-   if (il_cfg->sliding.kbd.duration <= 0) 
+   E_Kbd *kbd;
+   double t, v;
+
+   kbd = data;
+   t = ecore_loop_time_get() - kbd->start;
+   if (t > kbd->len) t = kbd->len;
+   if (kbd->len > 0.0)
      {
-        _e_kbd_border_hide(kbd->border);
-        kbd->actually_visible = 0;
-        _e_kbd_layout_send(kbd);
+       v = t / kbd->len;
+       v = 1.0 - v;
+       v = v * v * v * v;
+       v = 1.0 - v;
      }
    else
-     _e_kbd_slide(kbd, 0, (double)il_cfg->sliding.kbd.duration / 1000.0);
+     {
+       t = kbd->len;
+       v = 1.0;
+     }
+   kbd->adjust = (kbd->adjust_end * v) + (kbd->adjust_start  * (1.0 - v));
+   if (kbd->border)
+     e_border_fx_offset(kbd->border, 0, kbd->border->h - kbd->adjust);
+   if (t == kbd->len)
+     {
+       kbd->animator = NULL;
+       if (kbd->visible) 
+         {
+            _e_kbd_border_hide(kbd->border);
+            kbd->visible = 0;
+         }
+        else
+          kbd->visible = 1;
+       _e_kbd_layout_send(kbd);
+       return 0;
+     }
+   return 1;
 }
 
-static void 
-_e_kbd_layout_send(E_Kbd *kbd) 
+static E_Kbd *
+_e_kbd_by_border_get(E_Border *bd) 
+{
+   Eina_List *l, *ll;
+   E_Border *over;
+   E_Kbd *kbd;
+
+   if (!bd->stolen) return NULL;
+   EINA_LIST_FOREACH(kbds, l, kbd) 
+     {
+        if (kbd->border == bd) return kbd;
+        EINA_LIST_FOREACH(kbd->waiting_borders, ll, over)
+          if (over == bd) return kbd;
+     }
+   return NULL;
+}
+
+static void
+_e_kbd_layout_send(E_Kbd *kbd)
 {
-   Ecore_X_Virtual_Keyboard_State state;
+   Ecore_X_Virtual_Keyboard_State type;
 
-   state = ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF;
-   if ((kbd->actually_visible) && (!kbd->disabled)) 
+   if ((kbd->visible) && (!kbd->disabled))
      {
-        state = ECORE_X_VIRTUAL_KEYBOARD_STATE_ON;
-        if (kbd->layout == E_KBD_LAYOUT_ALPHA) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA;
-        else if (kbd->layout == E_KBD_LAYOUT_NUMERIC) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC;
-        else if (kbd->layout == E_KBD_LAYOUT_PIN) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN;
-        else if (kbd->layout == E_KBD_LAYOUT_PHONE_NUMBER) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER;
-        else if (kbd->layout == E_KBD_LAYOUT_HEX) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX;
-        else if (kbd->layout == E_KBD_LAYOUT_TERMINAL) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL;
-        else if (kbd->layout == E_KBD_LAYOUT_PASSWORD) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD;
-        else if (kbd->layout == E_KBD_LAYOUT_IP) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_IP;
-        else if (kbd->layout == E_KBD_LAYOUT_HOST) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_HOST;
-        else if (kbd->layout == E_KBD_LAYOUT_FILE) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_FILE;
-        else if (kbd->layout == E_KBD_LAYOUT_URL) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_URL;
-        else if (kbd->layout == E_KBD_LAYOUT_KEYPAD) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_KEYPAD;
-        else if (kbd->layout == E_KBD_LAYOUT_J2ME) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_J2ME;
-        else if (kbd->layout == E_KBD_LAYOUT_NONE) 
-          state = ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF;
+       type = ECORE_X_VIRTUAL_KEYBOARD_STATE_ON;
+       if (kbd->layout == E_KBD_LAYOUT_DEFAULT) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_ON;
+       else if (kbd->layout == E_KBD_LAYOUT_ALPHA) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA;
+       else if (kbd->layout == E_KBD_LAYOUT_NUMERIC) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC;
+       else if (kbd->layout == E_KBD_LAYOUT_PIN) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN;
+       else if (kbd->layout == E_KBD_LAYOUT_PHONE_NUMBER) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER;
+       else if (kbd->layout == E_KBD_LAYOUT_HEX) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX;
+       else if (kbd->layout == E_KBD_LAYOUT_TERMINAL) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL;
+       else if (kbd->layout == E_KBD_LAYOUT_PASSWORD) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD;
+       else if (kbd->layout == E_KBD_LAYOUT_NONE) 
+          type = ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF;
      }
+   else
+     type = ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF;
    if (kbd->border)
-     ecore_x_e_virtual_keyboard_state_send(kbd->border->client.win, state);
+     ecore_x_e_virtual_keyboard_state_send(kbd->border->client.win, type);
 }
 
 static void 
@@ -346,6 +371,50 @@ _e_kbd_border_hide(E_Border *bd)
 }
 
 static void 
+_e_kbd_border_adopt(E_Kbd *kbd, E_Border *bd) 
+{
+   kbd->border = bd;
+   bd->sticky = 1;
+   if (kbd->fullscreen)
+     e_border_layer_set(kbd->border, 250);
+   else
+     e_border_layer_set(kbd->border, 100);
+   if (!kbd->visible) 
+     {
+        e_border_fx_offset(kbd->border, 0, kbd->border->h);
+        _e_kbd_layout_send(kbd);
+     }
+   kbd->h = kbd->border->h;
+}
+
+static int
+_e_kbd_border_is_keyboard(E_Border *bd)
+{
+   if ((bd->client.vkbd.vkbd) || /* explicit hint that its a virtual keyboard */
+       /* legacy */
+       ( /* trap the matchbox qwerty and multitap kbd's */
+        (((bd->client.icccm.title) && (!strcmp(bd->client.icccm.title, "Keyboard"))) ||
+         ((bd->client.icccm.name) && ((!strcmp(bd->client.icccm.name, "multitap-pad")))))
+        && (bd->client.netwm.state.skip_taskbar)
+        && (bd->client.netwm.state.skip_pager)))
+     return 1;
+   return 0;
+}
+
+static void 
+_e_kbd_hide(E_Kbd *kbd) 
+{
+   if (!kbd->visible) return;
+   if (il_cfg->sliding.kbd.duration <= 0) 
+     {
+        _e_kbd_border_hide(kbd->border);
+        _e_kbd_layout_send(kbd);
+     }
+   else
+     _e_kbd_slide(kbd, 0, (double)il_cfg->sliding.kbd.duration / 1000.0);
+}
+
+static void 
 _e_kbd_slide(E_Kbd *kbd, int visible, double len) 
 {
    kbd->start = ecore_loop_time_get();
@@ -397,137 +466,11 @@ _e_kbd_all_layout_set(E_Kbd_Layout layout)
    Eina_List *l;
    E_Kbd *kbd;
 
-   EINA_LIST_FOREACH(kbds, l, kbd)
-     e_kbd_layout_set(kbd, layout);
-}
-
-static E_Kbd *
-_e_kbd_by_border_get(E_Border *bd) 
-{
-   Eina_List *l, *ll;
-   E_Border *over;
-   E_Kbd *kbd;
-
-   if (!bd->stolen) return NULL;
    EINA_LIST_FOREACH(kbds, l, kbd) 
-     {
-        if (kbd->border == bd) return kbd;
-        EINA_LIST_FOREACH(kbd->waiting_borders, ll, over)
-          if (over == bd) return kbd;
-     }
-   return NULL;
-}
-
-static void 
-_e_kbd_border_adopt(E_Kbd *kbd, E_Border *bd) 
-{
-   kbd->border = bd;
-   bd->sticky = 1;
-   if (kbd->fullscreen)
-     e_border_layer_set(kbd->border, 250);
-   else
-     e_border_layer_set(kbd->border, 100);
-   if (!kbd->actually_visible) 
-     e_border_fx_offset(kbd->border, 0, kbd->border->h);
-   kbd->h = kbd->border->h;
-}
-
-static void 
-_e_kbd_vkbd_state_handle(Ecore_X_Virtual_Keyboard_State state) 
-{
-   atom_focused_vkbd_state = state;
-   if (atom_focused_vkbd_state == 0) return;
-   if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) 
-     {
-//        _e_kbd_all_layout_set(E_KBD_LAYOUT_NONE);
-        _e_kbd_all_hide();
-     }
-   else 
-     {
-        if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_ALPHA);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_NUMERIC);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_PIN);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_PHONE_NUMBER);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_HEX);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_TERMINAL);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_PASSWORD);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_IP)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_IP);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_HOST)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_HOST);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_FILE)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_FILE);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_URL)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_URL);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_KEYPAD)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_KEYPAD);
-        else if (atom_focused_vkbd_state == ECORE_X_VIRTUAL_KEYBOARD_STATE_J2ME)
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_J2ME);
-        else
-          _e_kbd_all_layout_set(E_KBD_LAYOUT_DEFAULT);
-        _e_kbd_all_show();
-     }
-}
-
-static int 
-_e_kbd_border_is_keyboard(E_Border *bd) 
-{
-   if ((bd->client.vkbd.vkbd) || /* explicit hint that its a virtual keyboard */
-       /* legacy */
-       ( /* trap the matchbox qwerty and multitap kbd's */
-        (((bd->client.icccm.title) && (!strcmp(bd->client.icccm.title, "Keyboard"))) ||
-         ((bd->client.icccm.name) && ((!strcmp(bd->client.icccm.name, "multitap-pad")))))
-        && (bd->client.netwm.state.skip_taskbar)
-        && (bd->client.netwm.state.skip_pager)))
-     return 1;
-   return 0;
-}
-
-static int 
-_e_kbd_cb_animate(void *data) 
-{
-   E_Kbd *kbd;
-   double t, v;
-
-   if (!(kbd = data)) return 1;
-   t = ecore_loop_time_get() - kbd->start;
-   if (t > kbd->len) t = kbd->len;
-   if (kbd->len > 0.0) 
-     {
-        v = t / kbd->len;
-        v = 1.0 - v;
-        v = v * v * v * v;
-        v = 1.0 - v;
-     }
-   else 
-     {
-        t = kbd->len;
-        v = 1.0;
-     }
-   kbd->adjust = (kbd->adjust_end * v) + (kbd->adjust_start * (1.0 - v));
-   if (kbd->border)
-     e_border_fx_offset(kbd->border, 0, (kbd->border->h - kbd->adjust));
-   if (t == kbd->len) 
-     {
-        kbd->animator = NULL;
-        kbd->actually_visible = 1;
-        if (!kbd->visible) 
-          {
-             _e_kbd_border_hide(kbd->border);
-             kbd->actually_visible = 0;
-          }
-        return 0;
-     }
-   return 1;
+     e_kbd_layout_set(kbd, layout);
 }
 
+/* handlers */
 static int 
 _e_kbd_cb_client_message(void *data, int type, void *event) 
 {
@@ -535,8 +478,8 @@ _e_kbd_cb_client_message(void *data, int type, void *event)
 
    ev = event;
    if (ev->win != ecore_x_window_root_first_get()) return 1;
-   if ((ev->message_type == atom_mb_invoker) || 
-       (ev->message_type == atom_mtp_invoker)) 
+   if ((ev->message_type == ecore_x_atom_get("_MB_IM_INVOKER_COMMAND")) || 
+       (ev->message_type == ecore_x_atom_get("_MTP_IM_INVOKER_COMMAND")))
      {
         if (ev->data.l[0] == 1) _e_kbd_all_show();
         else if (ev->data.l[0] == 2) _e_kbd_all_hide();
@@ -552,6 +495,12 @@ _e_kbd_cb_border_remove(void *data, int type, void *event)
    E_Kbd *kbd;
 
    ev = event;
+   if (ev->border == focused_border) 
+     {
+        focused_border = NULL;
+        focused_vkbd_state = 0;
+        return 1;
+     }
    if (!(kbd = _e_kbd_by_border_get(ev->border))) return 1;
    if (kbd->border == ev->border) 
      {
@@ -567,10 +516,8 @@ _e_kbd_cb_border_remove(void *data, int type, void *event)
           }
         if (kbd->visible) 
           {
-             kbd->visible = 0;
-             _e_kbd_border_hide(kbd->border);
-             kbd->actually_visible = 0;
-             e_kbd_show(kbd);
+             _e_kbd_border_hide(ev->border);
+             e_kbd_hide(kbd);
           }
      }
    else
@@ -585,11 +532,32 @@ _e_kbd_cb_border_focus_in(void *data, int type, void *event)
 
    ev = event;
    if (_e_kbd_by_border_get(ev->border)) return 1;
-   if ((ev->border->need_fullscreen) || (ev->border->fullscreen))
-     e_kbd_fullscreen_set(ev->border->zone, 1);
+   focused_border = ev->border;
+   focused_vkbd_state = ev->border->client.vkbd.state;
+   if (focused_vkbd_state == 0) return 1;
+   if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF)
+     {
+       _e_kbd_all_layout_set(E_KBD_LAYOUT_NONE);
+       _e_kbd_all_hide();
+       return 1;
+     }
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_ALPHA);
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_NUMERIC);
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_PIN);
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_PHONE_NUMBER);
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_HEX);
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_TERMINAL);
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD)
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_PASSWORD);
    else
-     e_kbd_fullscreen_set(ev->border->zone, 0);
-   _e_kbd_vkbd_state_handle(ev->border->client.vkbd.state);
+     _e_kbd_all_layout_set(E_KBD_LAYOUT_DEFAULT);
+   _e_kbd_all_show();
    return 1;
 }
 
@@ -600,12 +568,10 @@ _e_kbd_cb_border_focus_out(void *data, int type, void *event)
 
    ev = event;
    if (_e_kbd_by_border_get(ev->border)) return 1;
-   if ((ev->border->need_fullscreen) || (ev->border->fullscreen))
-     e_kbd_fullscreen_set(ev->border->zone, 1);
-   else
-     e_kbd_fullscreen_set(ev->border->zone, 0);
    _e_kbd_all_layout_set(E_KBD_LAYOUT_NONE);
    _e_kbd_all_hide();
+   focused_border = NULL;
+   focused_vkbd_state = 0;
    return 1;
 }
 
@@ -615,17 +581,44 @@ _e_kbd_cb_border_property(void *data, int type, void *event)
    E_Event_Border_Property *ev;
 
    ev = event;
-   if (!ev->border->focused) return 1;
    if (_e_kbd_by_border_get(ev->border)) return 1;
-   if (ev->border->client.vkbd.state == atom_focused_vkbd_state) return 1;
+   if (!ev->border->focused) return 1;
+   if ((ev->border == focused_border) && 
+       (ev->border->client.vkbd.state == focused_vkbd_state)) return 1;
+   focused_vkbd_state = ev->border->client.vkbd.state;
    if ((ev->border->need_fullscreen) || (ev->border->fullscreen))
      e_kbd_fullscreen_set(ev->border->zone, 1);
    else
      e_kbd_fullscreen_set(ev->border->zone, 0);
-   _e_kbd_vkbd_state_handle(ev->border->client.vkbd.state);
+   if (ev->border->client.vkbd.state == 0) return 1;
+   /* app wants kbd off - then kbd off it is */
+   else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF)
+     _e_kbd_all_hide();
+   /* app wants something else than off... */
+   else
+     {
+       if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_ALPHA);
+       else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_NUMERIC);
+       else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_PIN);
+       else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_PHONE_NUMBER);
+       else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_HEX);
+       else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_TERMINAL);
+       else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD)
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_PASSWORD);
+       else
+         _e_kbd_all_layout_set(E_KBD_LAYOUT_DEFAULT);
+       _e_kbd_all_show();
+     }
    return 1;
 }
 
+/* hooks */
 static void 
 _e_kbd_cb_border_pre_post_fetch(void *data, void *data2) 
 {
@@ -634,28 +627,57 @@ _e_kbd_cb_border_pre_post_fetch(void *data, void *data2)
    if (!(bd = data2)) return;
    if (!bd->new_client) return;
    if (_e_kbd_by_border_get(bd)) return;
-   if (_e_kbd_border_is_keyboard(bd)) 
+   if (_e_kbd_border_is_keyboard(bd))
      {
-        Eina_List *l;
+       Eina_List *l;
         E_Kbd *kbd;
 
-        EINA_LIST_FOREACH(kbds, l, kbd) 
+       EINA_LIST_FOREACH(kbds, l, kbd)
           {
-             if (!kbd->border) 
-               {
-                  _e_kbd_border_adopt(kbd, bd);
-               }
-             else 
-               {
-                  kbd->waiting_borders = 
-                    eina_list_append(kbd->waiting_borders, bd);
-               }
-          }
+            if (!kbd->border)
+              {
+                 _e_kbd_border_adopt(kbd, bd);
+                 bd->stolen = 1;
+                 if (bd->remember)
+                   {
+                      if (bd->bordername)
+                        {
+                           eina_stringshare_del(bd->bordername);
+                           bd->bordername = NULL;
+                           bd->client.border.changed = 1;
+                        }
+                      e_remember_unuse(bd->remember);
+                      bd->remember = NULL;
+                   }
+                 eina_stringshare_replace(&bd->bordername, "borderless");
+                 bd->client.border.changed = 1;
+                 return;
+              }
+            else
+              {
+                 kbd->waiting_borders = eina_list_append(kbd->waiting_borders, bd);
+                 bd->stolen = 1;
+                 if (bd->remember)
+                   {
+                      if (bd->bordername)
+                        {
+                           eina_stringshare_del(bd->bordername);
+                           bd->bordername = NULL;
+                           bd->client.border.changed = 1;
+                        }
+                      e_remember_unuse(bd->remember);
+                      bd->remember = NULL;
+                   }
+                 eina_stringshare_replace(&bd->bordername, "borderless");
+                 bd->client.border.changed = 1;
+                 return;
+              }
+         }
      }
 }
 
 static void 
-_e_kbd_cb_border_post_assign(void *data, void *data2) 
+_e_kbd_cb_border_post_border_assign(void *data, void *data2) 
 {
    E_Border *bd;
    E_Kbd *kbd;
@@ -663,7 +685,6 @@ _e_kbd_cb_border_post_assign(void *data, void *data2)
 
    if (!(bd = data2)) return;
    if (!(kbd = _e_kbd_by_border_get(bd))) return;
-
    pbx = bd->x;
    pby = bd->y;
    pbw = bd->w;
@@ -728,7 +749,7 @@ _e_kbd_cb_border_post_assign(void *data, void *data2)
                       kbd->adjust_end -= (bd->h - kbd->h);
                    }
               }
-            else if (!kbd->actually_visible)
+            else if (!kbd->visible)
               e_border_fx_offset(kbd->border, 0, kbd->border->h);
             kbd->h = bd->h;
          }
@@ -736,17 +757,16 @@ _e_kbd_cb_border_post_assign(void *data, void *data2)
 }
 
 static void 
-_e_kbd_cb_border_end(void *data, void *data2) 
+_e_kbd_cb_border_eval_end(void *data, void *data2) 
 {
    E_Border *bd;
    E_Kbd *kbd;
 
    if (!(bd = data2)) return;
    if (!(kbd = _e_kbd_by_border_get(bd))) return;
-   if (kbd->border == bd)
+   if (kbd->border == bd) 
      {
-       if (!kbd->actually_visible)
-         _e_kbd_border_hide(kbd->border);
+        if (!kbd->visible) _e_kbd_border_hide(kbd->border);
      }
    else
      _e_kbd_border_hide(bd);

diff --git a/src/modules/illume2/e_kbd.h b/src/modules/illume2/e_kbd.h
index 43e2780..1edc41c 100644 (file)
--- a/src/modules/illume2/e_kbd.h
+++ b/src/modules/illume2/e_kbd.h
@@ -1,11 +1,10 @@
 #ifndef E_KBD_H
 #define E_KBD_H
 
-typedef struct _E_Kbd E_Kbd;
-
 #define E_KBD_TYPE 0xE1b0988
 
-typedef enum _E_Kbd_Layout
+typedef enum _E_Kbd_Layout E_Kbd_Layout;
+enum _E_Kbd_Layout
 {
    E_KBD_LAYOUT_NONE,
    E_KBD_LAYOUT_DEFAULT,
@@ -22,24 +21,22 @@ typedef enum _E_Kbd_Layout
    E_KBD_LAYOUT_URL, 
    E_KBD_LAYOUT_KEYPAD, 
    E_KBD_LAYOUT_J2ME
-} E_Kbd_Layout;
+};
 
-struct _E_Kbd
+typedef struct _E_Kbd E_Kbd;
+struct _E_Kbd 
 {
    E_Object e_obj_inherit;
-   E_Win *win;
    E_Border *border;
-   Ecore_Timer *delay_hide;
+   Ecore_Timer *timer;
    Ecore_Animator *animator;
-   Eina_List *waiting_borders;
    E_Kbd_Layout layout;
-   double start, len;
-
-   int h, adjust_start, adjust, adjust_end;
+   Eina_List *waiting_borders;
 
+   double start, len;
+   int h, adjust, adjust_start, adjust_end;
    unsigned char visible : 1;
-   unsigned char actually_visible : 1;
-   unsigned char disabled : 1; // if we have a real kbd plugged in
+   unsigned char disabled : 1;
    unsigned char fullscreen : 1;
 };
 
@@ -47,15 +44,15 @@ int e_kbd_init(E_Module *m);
 int e_kbd_shutdown(void);
 
 E_Kbd *e_kbd_new(void);
-void e_kbd_enable(E_Kbd *kbd);
-void e_kbd_disable(E_Kbd *kbd);
+void e_kbd_all_enable(void);
+void e_kbd_all_disable(void);
 void e_kbd_show(E_Kbd *kbd);
 void e_kbd_hide(E_Kbd *kbd);
-void e_kbd_safe_app_region_get(E_Zone *zone, int *x, int *y, int *w, int *h);
-void e_kbd_fullscreen_set(E_Zone *zone, int fullscreen);
+void e_kbd_enable(E_Kbd *kbd);
+void e_kbd_disable(E_Kbd *kbd);
 void e_kbd_layout_set(E_Kbd *kbd, E_Kbd_Layout layout);
-void e_kbd_all_enable(void);
-void e_kbd_all_disable(void);
+void e_kbd_fullscreen_set(E_Zone *zone, int fullscreen);
+void e_kbd_safe_app_region_get(E_Zone *zone, int *x, int *y, int *w, int *h);
 
 extern const char *mod_dir;
 

diff --git a/src/modules/illume2/e_mod_main.c b/src/modules/illume2/e_mod_main.c
index cec1a81..060ae8e 100644 (file)
--- a/src/modules/illume2/e_mod_main.c
+++ b/src/modules/illume2/e_mod_main.c
@@ -29,9 +29,6 @@ e_modapi_init(E_Module *m)
    /* create a new keyboard */
    kbd = e_kbd_new();
 
-   /* show the keyboard if needed */
-   e_kbd_show(kbd);
-
    /* return NULL on failure, anything else on success. the pointer
     * returned will be set as m->data for convenience tracking */
    return m;