refactor: replace code to use E_APIs to access the E_Client structure

Change-Id: I0d63e7a65ea48cbd1dd99e882eaa1466647108a9

diff --git a/src/e_mod_input_method_manager.c b/src/e_mod_input_method_manager.c
index cf57e5a13cfc6c57c1fa2d102a5d44e4f8a91e45..3f3edf77f4ad66369a77d32c5ebad60d1e5fa42c 100644 (file)
--- a/src/e_mod_input_method_manager.c
+++ b/src/e_mod_input_method_manager.c
@@ -74,17 +74,19 @@ static E_Client *find_visible_ec_by_pid(uint32_t pid)
 {
    E_Client *ec;
    Eina_List *l = NULL, *ec_list;
+   int ec_y;
 
    ec_list = e_comp_ec_list_get();
    EINA_LIST_FOREACH(ec_list, l, ec)
      {
         if (!ec) continue;
         if (e_object_is_del(E_OBJECT(ec))) continue;
-        if (ec->netwm.pid != pid) continue;
+        if (e_client_netwm_pid_get(ec) != pid) continue;
 
-        LOGI("pid(%d), name(%s), win(0x%08zx), visible(%d)", ec->netwm.pid, e_client_util_name_get(ec), e_client_util_win_get(ec), ec->visible);
+        LOGI("pid(%d), name(%s), win(0x%08zx), visible(%d)", e_client_netwm_pid_get(ec), e_client_util_name_get(ec), e_client_util_win_get(ec), e_client_visible_get(ec));
 
-        if (ec->y == 0 && ec->visible && ec->vkbd.vkbd == 0)
+        e_client_pos_get(ec, NULL, &ec_y);
+        if (ec_y == 0 && e_client_visible_get(ec) && (e_client_vkbd_vkbd_get(ec) == 0))
           return ec;
      }
 

diff --git a/src/e_mod_input_panel.c b/src/e_mod_input_panel.c
index d7a6f0818ba6d00fa86739555602183e055a27ac..d89e257963625f3596d2bc60fd8014c9b649f224 100644 (file)
--- a/src/e_mod_input_panel.c
+++ b/src/e_mod_input_panel.c
@@ -163,7 +163,7 @@ _e_input_floating_panel_surface_get()
    EINA_LIST_FOREACH_SAFE(g_input_panel->surfaces, l, l_next, ips)
      {
         if (!ips || !ips->ec) continue;
-        if (e_client_view_get(ips->ec) && ips->ec->vkbd.floating)
+        if (e_client_view_get(ips->ec) && e_client_vkbd_floating_state_get(ips->ec))
           {
              floating_ips = ips;
              break;
@@ -303,9 +303,14 @@ _e_input_panel_surface_show(E_Input_Panel_Surface *ips)
    Eina_List *l = NULL;
    E_Input_Panel_Surface *surface = NULL;
    E_Client *focused_ec = e_client_focused_get();
+   E_Client *focused_ec_parent = NULL;
+   E_Client *ips_ec_parent = NULL;
 
    if (!g_input_panel) return;
 
+   if (focused_ec)
+     focused_ec_parent = e_client_parent_get(focused_ec);
+
    /* When NULL passed, find the most appropriate surface */
    if (!ips)
      {
@@ -313,8 +318,8 @@ _e_input_panel_surface_show(E_Input_Panel_Surface *ips)
           {
              if (surface && surface->ec)
                {
-                  if (surface->ec->parent == focused_ec ||
-                      (focused_ec && surface->ec->parent == focused_ec->parent))
+                  if (e_client_parent_get(surface->ec) == focused_ec ||
+                      (focused_ec && e_client_parent_get(surface->ec) == focused_ec_parent))
                     {
                        ips = surface;
                     }
@@ -323,17 +328,18 @@ _e_input_panel_surface_show(E_Input_Panel_Surface *ips)
      }
 
    if (!ips) return;
+   ips_ec_parent = e_client_parent_get(ips->ec);
 
    LOGI("parent:%p, focus:%p, wait_update %d\n",
-        ips->ec ? ips->ec->parent : NULL, focused_ec, g_input_panel->wait_update);
+        ips->ec ? ips_ec_parent : NULL, focused_ec, g_input_panel->wait_update);
 
    if (g_input_panel->wait_update)
      {
         e_input_panel_wait_update_set(EINA_FALSE);
-        if (ips->ec && ips->ec->parent)
+        if (ips->ec && ips_ec_parent)
           {
-             LOGI("focused_ec:%p, focused_ec->parent:%p, ec->parent:%p\n", focused_ec, focused_ec ? focused_ec->parent : NULL, ips->ec->parent);
-             if (ips->ec->parent == focused_ec || (focused_ec && ips->ec->parent == focused_ec->parent))
+             LOGI("focused_ec:%p, focused_ec->parent:%p, ec->parent:%p\n", focused_ec, focused_ec ? focused_ec_parent : NULL, ips_ec_parent);
+             if (ips_ec_parent == focused_ec || (focused_ec && ips_ec_parent == focused_ec_parent))
                {
                   e_policy_conformant_part_update(ips->ec);
                   e_input_panel_visibility_change(EINA_TRUE);
@@ -403,12 +409,14 @@ _e_input_panel_surface_resource_destroy(struct wl_resource *resource)
    E_Input_Panel_Surface *ips = wl_resource_get_user_data(resource);
    E_Input_Panel *input_panel = NULL;
    E_Client *ec = NULL;
+   E_Client *ec_parent = NULL;
 
    CHECK_INPUT_PANEL_SURFACE(ips);
 
    if (!(input_panel = ips->input_panel)) return;
 
    ec = ips->ec;
+   ec_parent = e_client_parent_get(ec);
    if (ec && (!e_object_is_del(E_OBJECT(ec))))
      {
         if (e_comp_wl_data_check(ec))
@@ -417,10 +425,9 @@ _e_input_panel_surface_resource_destroy(struct wl_resource *resource)
                {
                   e_comp_wl_shell_unmap(ec);
                }
-             if (ec->parent)
+             if (ec_parent)
                {
-                  ec->parent->transients =
-                     eina_list_remove(ec->parent->transients, ec);
+                  e_client_transient_child_remove(ec_parent, ec);
                }
              e_comp_wl_shell_surface_set(ec, NULL);
           }
@@ -449,19 +456,21 @@ static void
 _e_input_panel_init_floating_position(E_Client *ec)
 {
    int zx, zy, zw, zh;
+   int ec_client_w, ec_client_h;
 
    if (!ec || !g_floating_info) return;
 
    e_client_base_output_resolution_desk_useful_geometry_get(ec, &zx, &zy, &zw, &zh, EINA_TRUE);
+   e_client_client_geometry_get(ec, NULL, NULL, &ec_client_w, &ec_client_h);
 
-   switch (ec->e.state.rot.ang.curr)
+   switch (e_client_e_state_rot_angle_current_get(ec))
      {
       case 90:
       case 270:
          if (!g_floating_info->init_landscape_position)
            {
-              g_floating_info->start_position.landscape_x = (zh - ec->client.h) / 2;
-              g_floating_info->start_position.landscape_y = (zw - ec->client.w) / 2;
+              g_floating_info->start_position.landscape_x = (zh - ec_client_h) / 2;
+              g_floating_info->start_position.landscape_y = (zw - ec_client_w) / 2;
               g_floating_info->init_landscape_position = EINA_TRUE;
            }
          break;
@@ -470,8 +479,8 @@ _e_input_panel_init_floating_position(E_Client *ec)
       default:
          if (!g_floating_info->init_portrait_position)
            {
-              g_floating_info->start_position.portrait_x = (zw - ec->client.w) / 2;
-              g_floating_info->start_position.portrait_y = (zh - ec->client.h) / 2;
+              g_floating_info->start_position.portrait_x = (zw - ec_client_w) / 2;
+              g_floating_info->start_position.portrait_y = (zh - ec_client_h) / 2;
               g_floating_info->init_portrait_position = EINA_TRUE;
            }
          break;
@@ -483,10 +492,12 @@ _e_input_panel_stay_within_screen(E_Client *ec, int x, int y, int *new_x, int *n
 {
    int zx, zy, zw, zh;
    int client_w, client_h;
+   int ec_w, ec_h;
 
    if (!ec || !g_floating_info) return;
 
    e_client_base_output_resolution_desk_useful_geometry_get(ec, &zx, &zy, &zw, &zh, EINA_TRUE);
+   e_client_size_get(ec, &ec_w, &ec_h);
 
    if (g_floating_info->new_width > 0 && g_floating_info->new_height > 0)
      {
@@ -495,11 +506,11 @@ _e_input_panel_stay_within_screen(E_Client *ec, int x, int y, int *new_x, int *n
      }
    else
      {
-        client_w = ec->w;
-        client_h = ec->h;
+        client_w = ec_w;
+        client_h = ec_h;
      }
 
-   switch (ec->e.state.rot.ang.curr)
+   switch (e_client_e_state_rot_angle_current_get(ec))
      {
       case 90:
       case 270:
@@ -543,15 +554,17 @@ _e_input_panel_convert_floating_position(E_Client *ec, int x, int y, int *new_x,
    int zx, zy, zw, zh;
    int cur_angle;
    int client_w, client_h;
+   int ec_w, ec_h;
 
    if (!ec || !g_floating_info) return;
 
-   cur_angle = ec->e.state.rot.ang.curr;
+   cur_angle = e_client_e_state_rot_angle_current_get(ec);
    if ((!g_floating_info->init_portrait_position && (cur_angle == 0 || cur_angle == 180)) ||
        (!g_floating_info->init_landscape_position && (cur_angle == 90 || cur_angle == 270)))
      _e_input_panel_init_floating_position(ec);
 
    e_client_base_output_resolution_desk_useful_geometry_get(ec, &zx, &zy, &zw, &zh, EINA_TRUE);
+   e_client_size_get(ec, &ec_w, &ec_h);
 
    if (g_floating_info->new_width > 0 && g_floating_info->new_height > 0)
      {
@@ -560,8 +573,8 @@ _e_input_panel_convert_floating_position(E_Client *ec, int x, int y, int *new_x,
      }
    else
      {
-        client_w = ec->w;
-        client_h = ec->h;
+        client_w = ec_w;
+        client_h = ec_h;
      }
 
    switch (cur_angle)
@@ -623,7 +636,7 @@ _e_input_panel_position_set(E_Client *ec, int w, int h)
    e_client_base_output_resolution_desk_useful_geometry_get(ec, &zx, &zy, &zw, &zh, EINA_TRUE);
 
    /* Get the position of center bottom each angles */
-   angle = ec->e.state.rot.ang.curr;
+   angle = e_client_e_state_rot_angle_current_get(ec);
    switch (angle)
      {
       case 90:
@@ -649,7 +662,7 @@ _e_input_panel_position_set(E_Client *ec, int w, int h)
          break;
      }
 
-   if (ec->vkbd.floating)
+   if (e_client_vkbd_floating_state_get(ec))
      {
         int sx, sy;
         if ((is_portrait && !g_floating_info->init_portrait_position) || (!is_portrait && !g_floating_info->init_landscape_position))
@@ -664,7 +677,9 @@ _e_input_panel_position_set(E_Client *ec, int w, int h)
 
         if (g_floating_info->resizing && g_floating_info->new_width > 0 && g_floating_info->new_height > 0)
           {
-             if (g_floating_info->new_width != ec->w || g_floating_info->new_height != ec->h)
+             int ec_w, ec_h;
+             e_client_size_get(ec, &ec_w, &ec_h);
+             if (g_floating_info->new_width != ec_w || g_floating_info->new_height != ec_h)
                {
                   LOGI("x : %d, y : %d, w : %d, h : %d", nx, ny, g_floating_info->new_width, g_floating_info->new_height);
                   e_client_util_move_resize_without_frame(ec, nx, ny, g_floating_info->new_width, g_floating_info->new_height);
@@ -689,41 +704,43 @@ static void
 _e_input_panel_floating_position_align_set(E_Client *ec)
 {
    int x, y;
+   int ec_w, ec_h;
 
    if (!ec || !g_floating_info) return;
 
    x = g_floating_info->align_position.x;
    y = g_floating_info->align_position.y;
+   e_client_size_get(ec, &ec_w, &ec_h);
 
    switch (g_floating_info->align)
      {
         case E_INPUT_PANEL_ALIGN_TOP_CENTER:
-          x -= (ec->w / 2);
+          x -= (ec_w / 2);
           break;
         case E_INPUT_PANEL_ALIGN_TOP_RIGHT:
-          x -= ec->w;
+          x -= ec_w;
           break;
         case E_INPUT_PANEL_ALIGN_MIDDLE_LEFT:
-          y -= (ec->h / 2);
+          y -= (ec_h / 2);
           break;
         case E_INPUT_PANEL_ALIGN_MIDDLE_CENTER:
-          x -= (ec->w / 2);
-          y -= (ec->h / 2);
+          x -= (ec_w / 2);
+          y -= (ec_h / 2);
           break;
         case E_INPUT_PANEL_ALIGN_MIDDLE_RIGHT:
-          x -= ec->w;
-          y -= (ec->h / 2);
+          x -= ec_w;
+          y -= (ec_h / 2);
           break;
         case E_INPUT_PANEL_ALIGN_BOTTOM_LEFT:
-          y -= ec->h;
+          y -= ec_h;
           break;
         case E_INPUT_PANEL_ALIGN_BOTTOM_CENTER:
-          x -= (ec->w / 2);
-          y -= ec->h;
+          x -= (ec_w / 2);
+          y -= ec_h;
           break;
         case E_INPUT_PANEL_ALIGN_BOTTOM_RIGHT:
-          x -= ec->w;
-          y -= ec->h;
+          x -= ec_w;
+          y -= ec_h;
           break;
         case E_INPUT_PANEL_ALIGN_TOP_LEFT:
         default:
@@ -732,7 +749,7 @@ _e_input_panel_floating_position_align_set(E_Client *ec)
           break;
      }
 
-   LOGI("x : %d, y : %d, w : %d, h : %d", x, y, ec->w, ec->h);
+   LOGI("x : %d, y : %d, w : %d, h : %d", x, y, ec_w, ec_h);
    e_input_panel_floating_position_set(x, y);
 
    g_floating_info->align_position.x = -1;
@@ -742,24 +759,30 @@ _e_input_panel_floating_position_align_set(E_Client *ec)
 static void
 _ips_show(E_Client *ec)
 {
-   if (ec->visible)
+   if (e_client_visible_get(ec))
      return;
 
    LOGI("IPS::SHOW\n");
 
-   if (ec->vkbd.floating && g_floating_info->align_position.x >= 0 && g_floating_info->align_position.y >= 0)
+   if (e_client_vkbd_floating_state_get(ec) && g_floating_info->align_position.x >= 0 && g_floating_info->align_position.y >= 0)
      _e_input_panel_floating_position_align_set(ec);
 
-   _e_input_panel_position_set(ec, ec->client.w, ec->client.h);
+   int ec_client_w, ec_client_h;
+   e_client_client_geometry_get(ec, NULL, NULL, &ec_client_w, &ec_client_h);
+   _e_input_panel_position_set(ec, ec_client_w, ec_client_h);
 
-   ec->visible = EINA_TRUE;
+   e_client_visible_set(ec, EINA_TRUE);
 
-   if (ec->iconic)
+   if (e_client_iconic_get(ec))
      e_client_uniconify(ec);
 
-   e_view_client_geometry_set(e_client_view_get(ec), ec->x, ec->y, ec->w, ec->h);
+   int ec_x, ec_y, ec_w, ec_h;
+   e_client_pos_get(ec, &ec_x, &ec_y);
+   e_client_size_get(ec, &ec_w, &ec_h);
+
+   e_view_client_geometry_set(e_client_view_get(ec), ec_x, ec_y, ec_w, ec_h);
    e_view_client_show(e_client_view_get(ec));
-   e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+   e_view_client_damage(e_client_view_get(ec), 0, 0, ec_w, ec_h);
 }
 
 static void
@@ -772,7 +795,7 @@ _e_input_panel_surface_visible_update(E_Input_Panel_Surface *ips)
    if (!(ec = ips->ec)) return;
 
    if (e_object_is_del(E_OBJECT(ec))) return;
-   if ((ips->showing) && (e_pixmap_usable_get(ec->pixmap)))
+   if ((ips->showing) && (e_pixmap_usable_get(e_client_pixmap_get(ec))))
      {
         /* Now we can assure that previous SHOW request actually succeeded,
          * no need for trying re-run panel show command */
@@ -795,11 +818,11 @@ _e_input_panel_surface_visible_update(E_Input_Panel_Surface *ips)
    else
      {
         LOGI("IPS::DEFER_SHOW::HIDE\n");
-        ec->visible = EINA_FALSE;
+        e_client_visible_set(ec, EINA_FALSE);
         /* We have to reset the flag of pending_show to prevent showing after
          * finish the rotation. Directly set this value, since there is no way
          * to tell it needs to be hidden to rotation module for now. */
-        ec->e.state.rot.pending_show = 0;
+        e_client_e_state_rot_pending_show_set(ec, EINA_FALSE);
         e_view_client_hide(e_client_view_get(ec));
         E_FREE_FUNC(ips->eh.buf_change, ecore_event_handler_del);
         ips->need_show = EINA_FALSE;
@@ -833,6 +856,7 @@ _e_input_panel_surface_map(struct wl_resource *resource)
 {
    E_Input_Panel_Surface *ips  = wl_resource_get_user_data(resource);
    E_Client *ec;
+   E_Client *ec_parent;
 
    CHECK_INPUT_PANEL_SURFACE(ips);
 
@@ -853,14 +877,15 @@ _e_input_panel_surface_map(struct wl_resource *resource)
      }
 
    /* NOTE: we need to set mapped, so that avoid showing evas_object and continue buffer's commit process. */
-   if ((!e_comp_wl_mapped_get(ec)) && (e_pixmap_usable_get(ec->pixmap)))
+   if ((!e_comp_wl_mapped_get(ec)) && (e_pixmap_usable_get(e_client_pixmap_get(ec))))
      {
         e_comp_wl_mapped_set(ec, EINA_TRUE);
-        ec->first_mapped = EINA_TRUE;
+        e_client_first_mapped_set(ec, EINA_TRUE);
      }
 
-   if (ec->parent)
-     e_input_panel_transient_for_set(ec->parent);
+   ec_parent = e_client_parent_get(ec);
+   if (ec_parent)
+     e_input_panel_transient_for_set(ec_parent);
 }
 
 static void
@@ -897,15 +922,18 @@ _e_input_panel_client_cb_rotation_change_end(void *data, int type, void *event)
    E_Client *ec;
    E_Input_Panel_Surface *ips = data;
    E_Event_Client_Rotation_Change_End *ev = event;
+   int ec_client_w, ec_client_h;
 
    ec = ev->ec;
    if (ec != ips->ec)
      goto end;
 
-   if (ips->showing) {
-        LOGI("current angle : %d", ec->e.state.rot.ang.curr);
-        _e_input_panel_position_set(ec, ec->client.w, ec->client.h);
-   }
+   if (ips->showing)
+     {
+        e_client_client_geometry_get(ec, NULL, NULL, &ec_client_w, &ec_client_h);
+        LOGI("current angle : %d", e_client_e_state_rot_angle_current_get(ec));
+        _e_input_panel_position_set(ec, ec_client_w, ec_client_h);
+     }
 
 end:
    return ECORE_CALLBACK_PASS_ON;
@@ -914,6 +942,8 @@ end:
 static bool check_rotation_size(E_Client *ec, int angle, int w, int h)
 {
    int i;
+   int rot_w, rot_h;
+
    switch (angle)
      {
       case 0:   i = 0; break;
@@ -923,8 +953,9 @@ static bool check_rotation_size(E_Client *ec, int angle, int w, int h)
       default:  i = 0; break;
      }
 
-   if ((w != ec->e.state.rot.geom[i].w) ||
-       (h != ec->e.state.rot.geom[i].h))
+   e_client_e_state_rot_geometry_get(ec, i, NULL, NULL, &rot_w, &rot_h);
+   if ((w != rot_w) ||
+       (h != rot_h))
      return false;
    else
      return true;
@@ -948,7 +979,7 @@ _e_input_panel_client_cb_rotation_geometry_set(void *data, int type, void *event
    if (ips->resizing)
      goto end;
 
-   if (ev->angle != ec->e.state.rot.ang.curr)
+   if (ev->angle != e_client_e_state_rot_angle_current_get(ec))
      goto end;
 
    e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
@@ -983,7 +1014,7 @@ _e_input_panel_client_cb_visibility_change(void *data, int type, void *event)
    if (ips->resizing)
      goto end;
 
-   if (ec->visibility.obscured == E_VISIBILITY_FULLY_OBSCURED && !e_input_panel_show_request_flag_get())
+   if (e_client_visibility_obscured_get(ec) == E_VISIBILITY_FULLY_OBSCURED && !e_input_panel_show_request_flag_get())
      e_input_panel_visibility_change(EINA_FALSE);
 
 end:
@@ -1011,6 +1042,7 @@ _e_ips_cb_view_resize(struct wl_listener *listener, void *data)
    int w, h;
    int angle;
    int i;
+   int rot_w, rot_h;
 
    ips = wl_container_of(listener, ips, resize_listener);
 
@@ -1023,7 +1055,7 @@ _e_ips_cb_view_resize(struct wl_listener *listener, void *data)
 
    e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
 
-   LOGI("current angle : %d, w: %d, h: %d", ec->e.state.rot.ang.curr, w, h);
+   LOGI("current angle : %d, w: %d, h: %d", e_client_e_state_rot_angle_current_get(ec), w, h);
    _e_input_panel_position_set(ec, w, h);
 
    g_floating_info->resizing = EINA_FALSE;
@@ -1032,7 +1064,7 @@ _e_ips_cb_view_resize(struct wl_listener *listener, void *data)
    if (!ips) return;
    if (!ips->resizing) return;
 
-   angle = ec->e.state.rot.ang.curr;
+   angle = e_client_e_state_rot_angle_current_get(ec);
    switch (angle)
      {
       case 0:   i = 0; break;
@@ -1042,8 +1074,9 @@ _e_ips_cb_view_resize(struct wl_listener *listener, void *data)
       default:  i = 0; break;
      }
 
-   if ((w == ec->e.state.rot.geom[i].w) ||
-       (h == ec->e.state.rot.geom[i].h))
+   e_client_e_state_rot_geometry_get(ec, i, NULL, NULL, &rot_w, &rot_h);
+   if ((w == rot_w) ||
+       (h == rot_h))
      {
         LOGI("Resize Done to Rotation Geometry. Starting Drawing Again");
         _e_input_panel_start_drawing(ips);
@@ -1071,7 +1104,7 @@ _e_ips_cb_mouse_up(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED
    E_Client *ec;
 
    ec = data;
-   if (e_object_is_del(E_OBJECT(ec)) || !ec->vkbd.floating || !g_floating_info)
+   if (e_object_is_del(E_OBJECT(ec)) || !e_client_vkbd_floating_state_get(ec) || !g_floating_info)
      return;
 
    g_floating_info->mouse_pressed = EINA_FALSE;
@@ -1091,7 +1124,7 @@ _e_ips_cb_mouse_down(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUS
    Evas_Event_Mouse_Move *ev = event_info;
 
    ec = data;
-   if (e_object_is_del(E_OBJECT(ec)) || !ec->vkbd.floating || !g_floating_info)
+   if (e_object_is_del(E_OBJECT(ec)) || !e_client_vkbd_floating_state_get(ec) || !g_floating_info)
      return;
 
    g_floating_info->mouse_pressed = EINA_TRUE;
@@ -1109,7 +1142,7 @@ _e_ips_cb_mouse_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *ev
    int d_x, d_y;
 
    ec = data;
-   if (e_object_is_del(E_OBJECT(ec)) || !ec->vkbd.floating || !g_floating_info)
+   if (e_object_is_del(E_OBJECT(ec)) || !e_client_vkbd_floating_state_get(ec) || !g_floating_info)
      return;
 
    if (!g_floating_info->moving_req || !g_floating_info->mouse_pressed)
@@ -1126,7 +1159,7 @@ _e_ips_cb_mouse_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *ev
    g_floating_info->before_canvas_x = ev->cur.canvas.x;
    g_floating_info->before_canvas_y = ev->cur.canvas.y;
 
-   if (ec->e.state.rot.ang.curr == 90 || ec->e.state.rot.ang.curr == 270)
+   if (e_client_e_state_rot_angle_current_get(ec) == 90 || e_client_e_state_rot_angle_current_get(ec) == 270)
      {
         g_floating_info->start_position.landscape_x = n_x;
         g_floating_info->start_position.landscape_y = n_y;
@@ -1158,7 +1191,7 @@ _e_input_panel_rotation_geometry_set(void *data, E_Client *ec)
      return;
 
    e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
-   cur_angle = ec->e.state.rot.ang.curr;
+   cur_angle = e_client_e_state_rot_angle_current_get(ec);
    LOGI("current angle : %d, w: %d, h: %d", cur_angle, w, h);
 
    if (!check_rotation_size(ec, cur_angle, w, h) && (e_text_input_activation_state_get() || ips->showing))
@@ -1189,7 +1222,7 @@ _e_input_panel_cb_surface_get(struct wl_client *client, struct wl_resource *reso
 
    CHECK_ECLIENT(ec, surface_resource);
 
-   if (e_pixmap_type_get(ec->pixmap) != E_PIXMAP_TYPE_WL)
+   if (e_pixmap_type_get(e_client_pixmap_get(ec)) != E_PIXMAP_TYPE_WL)
      return;
 
    if (!e_comp_wl_data_check(ec))
@@ -1218,30 +1251,31 @@ _e_input_panel_cb_surface_get(struct wl_client *client, struct wl_resource *reso
      }
    e_comp_wl_shell_surface_set(ec, shell_surface);
 
-   if (ec->ignored)
+   if (e_client_ignored_get(ec))
      e_client_unignore(ec);
 
    /* set input panel client properties */
-   ec->borderless = EINA_TRUE;
-   ec->argb = EINA_TRUE;
-   ec->lock_border = EINA_TRUE;
-   ec->lock_focus_in = ec->lock_focus_out = EINA_TRUE;
-   ec->netwm.state.skip_taskbar = EINA_TRUE;
-   ec->netwm.state.skip_pager = EINA_TRUE;
-   ec->border_size = 0;
-   ec->vkbd.vkbd = 1;
-   ec->icccm.window_role = eina_stringshare_add("input_panel_surface");
-   if (!ec->icccm.title)
-     ec->icccm.title = eina_stringshare_add("Keyboard");
+   e_client_borderless_set(ec, EINA_TRUE);
+   e_client_argb_set(ec, EINA_TRUE);
+   e_client_lock_border_set(ec, EINA_TRUE);
+   e_client_lock_focus_in_set(ec, EINA_TRUE);
+   e_client_lock_focus_out_set(ec, EINA_TRUE);
+   e_client_netwm_state_skip_taskbar_set(ec, EINA_TRUE);
+   e_client_netwm_state_skip_pager_set(ec, EINA_TRUE);
+   e_client_border_size_set(ec, 0);
+   e_client_vkbd_vkbd_set(ec, EINA_TRUE);
+   e_client_icccm_window_role_set(ec, "input_panel_surface");
+   if (!e_client_icccm_title_get(ec))
+     e_client_icccm_title_set(ec, "Keyboard");
 
    /* skip iconify */
-   ec->exp_iconify.skip_iconify = 1;
+   e_client_iconify_extra_info_skip_iconify_set(ec, EINA_TRUE);
    e_client_layer_set(ec, E_LAYER_CLIENT_ABOVE);
    e_client_raise(ec);
 
-   evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOUSE_UP, _e_ips_cb_mouse_up, ec);
-   evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOUSE_DOWN, _e_ips_cb_mouse_down, ec);
-   evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOUSE_MOVE, _e_ips_cb_mouse_move, ec);
+   evas_object_event_callback_add(e_client_frame_get(ec), EVAS_CALLBACK_MOUSE_UP, _e_ips_cb_mouse_up, ec);
+   evas_object_event_callback_add(e_client_frame_get(ec), EVAS_CALLBACK_MOUSE_DOWN, _e_ips_cb_mouse_down, ec);
+   evas_object_event_callback_add(e_client_frame_get(ec), EVAS_CALLBACK_MOUSE_MOVE, _e_ips_cb_mouse_move, ec);
 
    E_Comp_Wl_Shell_Surface_Api api = {
       .configure_send = NULL,
@@ -1422,6 +1456,8 @@ e_input_panel_client_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h)
    Eina_List *l;
    int angle = 0;
    int zx, zy, zw, zh;
+   int ips_ec_x, ips_ec_y, ips_ec_w, ips_ec_h;
+   int ips_ec_client_w, ips_ec_client_h;
 
    if (!g_input_panel) return EINA_FALSE;
    if (!x || !y || !w || !h) return EINA_FALSE;
@@ -1431,37 +1467,40 @@ e_input_panel_client_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h)
         if (!ips || !ips->ec) continue;
         if (ips->ec == ec || !ec)
           {
-             angle = ips->ec->e.state.rot.ang.next < 0 ?
-                ips->ec->e.state.rot.ang.curr :
-                ips->ec->e.state.rot.ang.next;
+             angle = e_client_e_state_rot_angle_next_get(ips->ec) < 0 ?
+                e_client_e_state_rot_angle_current_get(ips->ec) :
+                e_client_e_state_rot_angle_next_get(ips->ec);
 
              e_client_base_output_resolution_desk_useful_geometry_get(ips->ec, &zx, &zy, &zw, &zh, EINA_TRUE);
+             e_client_pos_get(ips->ec, &ips_ec_x, &ips_ec_y);
+             e_client_size_get(ips->ec, &ips_ec_w, &ips_ec_h);
+             e_client_client_geometry_get(ips->ec, NULL, NULL, &ips_ec_client_w, &ips_ec_client_h);
              switch (angle)
                {
                 case 90:
-                   *x = zh - ips->ec->y - ips->ec->client.h;
-                   *y = ips->ec->x;
-                   *w = ips->ec->h;
-                   *h = ips->ec->w;
+                   *x = zh - ips_ec_y - ips_ec_client_h;
+                   *y = ips_ec_x;
+                   *w = ips_ec_h;
+                   *h = ips_ec_w;
                    break;
                 case 180:
-                   *x = zh - ips->ec->y - ips->ec->client.h;
-                   *y = zw - ips->ec->x - ips->ec->client.w;
-                   *w = ips->ec->w;
-                   *h = ips->ec->h;
+                   *x = zh - ips_ec_y - ips_ec_client_h;
+                   *y = zw - ips_ec_x - ips_ec_client_w;
+                   *w = ips_ec_w;
+                   *h = ips_ec_h;
                    break;
                 case 270:
-                   *x = ips->ec->y;
-                   *y = zw - ips->ec->x - ips->ec->client.w;
-                   *w = ips->ec->h;
-                   *h = ips->ec->w;
+                   *x = ips_ec_y;
+                   *y = zw - ips_ec_x - ips_ec_client_w;
+                   *w = ips_ec_h;
+                   *h = ips_ec_w;
                    break;
                 case 0:
                 default:
-                   *x = ips->ec->x;
-                   *y = ips->ec->y;
-                   *w = ips->ec->w;
-                   *h = ips->ec->h;
+                   *x = ips_ec_x;
+                   *y = ips_ec_y;
+                   *w = ips_ec_w;
+                   *h = ips_ec_h;
                    break;
                }
 
@@ -1560,7 +1599,7 @@ _ips_client_frame_flush(E_Input_Panel_Surface  *ips)
      return;
 
    LOGI("IPS::FRAME::FLUSH ec %p\n", ips->ec);
-   e_pixmap_image_clear(ips->ec->pixmap, EINA_TRUE);
+   e_pixmap_image_clear(e_client_pixmap_get(ips->ec), EINA_TRUE);
 }
 
 static Eina_Bool
@@ -1628,7 +1667,7 @@ e_input_panel_transient_for_set(E_Client *parent)
 {
    E_Input_Panel_Surface *ips;
    Eina_List *l;
-   E_Client *parent_window = (parent && parent->parent) ? parent->parent : parent;
+   E_Client *parent_window = e_client_parent_get(parent) ? e_client_parent_get(parent) : parent;
    E_Client *ec_parent = parent_window;
 
    LOGI("TRANSIENT_FOR::transient_for_set : parent(%p), parent window(%p)\n", parent, parent_window);
@@ -1672,6 +1711,7 @@ e_input_panel_floating_position_set(int x, int y)
    int cur_angle;
    E_Client *floating_ec = NULL;
    E_Input_Panel_Surface *floating_ips = NULL;
+   E_Zone *zone = NULL;
 
    floating_ips = _e_input_floating_panel_surface_get();
    if (floating_ips)
@@ -1689,9 +1729,12 @@ e_input_panel_floating_position_set(int x, int y)
      }
 
    if (floating_ips->showing)
-     cur_angle = floating_ec->e.state.rot.ang.curr;
+     cur_angle = e_client_e_state_rot_angle_current_get(floating_ec);
    else
-     cur_angle = e_zone_rotation_curr_angle_get(floating_ec->zone);
+     {
+        zone = e_comp_zone_find_by_ec(floating_ec);
+        cur_angle = e_zone_rotation_curr_angle_get(zone);
+     }
 
    LOGI("current angle : %d", cur_angle);
    switch (cur_angle)
@@ -1714,6 +1757,7 @@ e_input_panel_floating_position_set(int x, int y)
    if (floating_ips->showing)
      {
         int client_w, client_h;
+        int floating_w, floating_h;
 
         if (g_floating_info->new_width > 0 && g_floating_info->new_height > 0)
           {
@@ -1722,8 +1766,9 @@ e_input_panel_floating_position_set(int x, int y)
           }
         else
           {
-             client_w = floating_ec->w;
-             client_h = floating_ec->h;
+             e_client_size_get(floating_ec, &floating_w, &floating_h);
+             client_w = floating_w;
+             client_h = floating_h;
           }
 
         g_floating_info->resizing = EINA_TRUE;
@@ -1777,7 +1822,7 @@ int e_input_panel_is_effect_running(void)
                 Do we need to check currently effect type?
                 then what flag do we check? ips->ec->visible or ips->showing?
               */
-             if (ips->ec->visible)
+             if (e_client_visible_get(ips->ec))
                run_type = 1; // show effect is running
              else
                run_type = 2; // hide effect is running
@@ -1801,9 +1846,9 @@ void e_input_panel_floating_panel_set(Eina_Bool state)
      {
         if (ips && ips->ec)
           {
-             if (ips->ec->vkbd.floating == state) continue;
-             ips->ec->vkbd.floating = state;
-             if (ips->ec->vkbd.floating)
+             if (e_client_vkbd_floating_state_get(ips->ec) == state) continue;
+             e_client_vkbd_floating_state_set(ips->ec, state);
+             if (e_client_vkbd_floating_state_get(ips->ec))
                {
                   e_policy_conformant_part_del(ips->ec);
 
@@ -1842,7 +1887,7 @@ Eina_Bool e_input_panel_floating_mode_get()
      {
         if (ips && ips->ec)
           {
-             ret = ips->ec->vkbd.floating;
+             ret = e_client_vkbd_floating_state_get(ips->ec);
           }
      }
 
@@ -1890,7 +1935,7 @@ void e_input_panel_floating_panel_move_resize(int x, int y, int w, int h)
 
    floating_ips = _e_input_floating_panel_surface_get();
    if (floating_ips && floating_ips->ec)
-     angle = floating_ips->ec->e.state.rot.ang.curr;
+     angle = e_client_e_state_rot_angle_current_get(floating_ips->ec);
 
    if (angle == 90 || angle == 270)
      {

diff --git a/src/e_mod_main.c b/src/e_mod_main.c
index 6fdb6265115f3edddd0969b08ea32ee700b18772..1c552b96730f614b45db12dcd296c966cf3edbbe 100644 (file)
--- a/src/e_mod_main.c
+++ b/src/e_mod_main.c
@@ -249,7 +249,8 @@ _e_text_input_send_input_panel_geometry(struct wl_resource *resource, int x, int
    if (client_surface_ec)
      {
         // find input panel
-        EINA_LIST_FOREACH(client_surface_ec->transients, l, ips_ec)
+        Eina_List *transients = e_client_transient_children_get(client_surface_ec);
+        EINA_LIST_FOREACH(transients, l, ips_ec)
           {
              if (e_input_panel_client_find(ips_ec)) break;
           }
@@ -267,9 +268,9 @@ _e_text_input_send_input_panel_geometry(struct wl_resource *resource, int x, int
    // 1. Modify the incoming client coordinate system to match the display server's coordinate system according to the keyboard's rotation angle.
    if (ips_ec)
      {
-        angle = ips_ec->e.state.rot.ang.next < 0 ?
-            ips_ec->e.state.rot.ang.curr :
-            ips_ec->e.state.rot.ang.next;
+        angle = e_client_e_state_rot_angle_next_get(ips_ec) < 0 ?
+            e_client_e_state_rot_angle_current_get(ips_ec) :
+            e_client_e_state_rot_angle_next_get(ips_ec);
 
         e_client_base_output_resolution_desk_useful_geometry_get(ips_ec, &zx, &zy, &zw, &zh, EINA_TRUE);
         LOGI("ips_ec(%p) zx(%d) zy(%d) zw(%d) zh(%d)", ips_ec, zx, zy, zw, zh);
@@ -340,12 +341,12 @@ _e_text_input_send_input_panel_geometry(struct wl_resource *resource, int x, int
    // 4. Change the geometry to fit the client coordinate system according to the client_surface_ec's rotation angle.
    if (client_surface_ec)
      {
-        angle = client_surface_ec->e.state.rot.ang.next < 0 ?
-            client_surface_ec->e.state.rot.ang.curr :
-            client_surface_ec->e.state.rot.ang.next;
+        angle = e_client_e_state_rot_angle_next_get(client_surface_ec) < 0 ?
+            e_client_e_state_rot_angle_current_get(client_surface_ec) :
+            e_client_e_state_rot_angle_next_get(client_surface_ec);
 
-        LOGI("curr : %d, next : %d, angle : %d\n", client_surface_ec->e.state.rot.ang.curr,
-             client_surface_ec->e.state.rot.ang.next, angle);
+        LOGI("curr : %d, next : %d, angle : %d\n", e_client_e_state_rot_angle_current_get(client_surface_ec),
+             e_client_e_state_rot_angle_next_get(client_surface_ec), angle);
 
         e_client_base_output_resolution_desk_useful_geometry_get(client_surface_ec, &zx, &zy, &zw, &zh, EINA_TRUE);
         LOGI("client surface ec(%p) zx(%d) zy(%d) zw(%d) zh(%d)", client_surface_ec, zx, zy, zw, zh);
@@ -1396,7 +1397,7 @@ _e_text_input_cb_input_panel_show(struct wl_client *client, struct wl_resource *
              int angle = 0;
              if (client_surface_ec)
                {
-                  E_Util_Transform *transform = &client_surface_ec->transform_core.result.transform;
+                  E_Util_Transform *transform = e_client_transform_core_result_transform_get(client_surface_ec);
                   Eina_Bool transformEnabled = e_client_transform_core_enable_get(client_surface_ec);
 
                   if (transformEnabled && transform != 0)
@@ -1406,7 +1407,7 @@ _e_text_input_cb_input_panel_show(struct wl_client *client, struct wl_resource *
                         * when they're showing on display. so, adjust transformed angle to window rotation angle */
                        angle = (360 - angle) % 360;
                     }
-                  angle += client_surface_ec->e.state.rot.ang.curr;
+                  angle += e_client_e_state_rot_angle_current_get(client_surface_ec);
                }
 
              zwp_input_method_v1_send_show_input_panel(input_method->resource, input_method->context->resource, angle);
@@ -1734,7 +1735,7 @@ _e_text_input_cb_get_hide_permission(struct wl_client *client EINA_UNUSED, struc
      {
         if (focused_ec != client_surface_ec)
           {
-             E_Window_Type focus_win_type = focused_ec->netwm.type;
+             E_Window_Type focus_win_type = e_client_netwm_type_get(focused_ec);
              LOGI("Window ID : 0x%08x, Name : %s, type : %d\n", (unsigned int)e_client_util_win_get(focused_ec), (char *)e_client_util_name_get(focused_ec), focus_win_type);
 
              if (focus_win_type == E_WINDOW_TYPE_NOTIFICATION ||
@@ -2247,7 +2248,7 @@ e_client_rotation_is_progress(E_Client *ec)
 {
    if (!ec) return EINA_TRUE;
 
-   if (ec->e.state.rot.ang.next == -1)
+   if (e_client_e_state_rot_angle_next_get(ec) == E_CLIENT_ROTATION_ANGLE_UNKNOWN)
      return EINA_FALSE;
    else
      return EINA_TRUE;
@@ -2259,6 +2260,7 @@ _e_text_input_method_context_cb_client_resize(void *data EINA_UNUSED, int type E
    E_Event_Client *ev;
    E_Client *ec;
    Eina_Bool found;
+   int ec_w, ec_h;
 
    ev = (E_Event_Client *)event;
    EINA_SAFETY_ON_NULL_RETURN_VAL(ev, ECORE_CALLBACK_PASS_ON);
@@ -2268,7 +2270,8 @@ _e_text_input_method_context_cb_client_resize(void *data EINA_UNUSED, int type E
 
    found = e_input_panel_client_find(ec);
    if (!found) return ECORE_CALLBACK_PASS_ON;
-   if ((ec->w < 1) && (ec->h < 1)) return ECORE_CALLBACK_PASS_ON;
+   e_client_size_get(ec, &ec_w, &ec_h);
+   if ((ec_w < 1) && (ec_h < 1)) return ECORE_CALLBACK_PASS_ON;
 
    e_text_input_update_input_panel_geometry(ec);