e_desk_area: move maximize/unmaximize listener to desk_area

e_desk_area manages the maximize/unmaximize state of e_client
instead of e_zone.

Change-Id: I677c169ec48cf63f35b7d33a4a145b5e9aa274eb

diff --git a/src/bin/e_desk_area.c b/src/bin/e_desk_area.c
index 40f19db..55aa260 100644 (file)
--- a/src/bin/e_desk_area.c
+++ b/src/bin/e_desk_area.c
@@ -67,6 +67,8 @@ struct _E_Desk_Area_Private_Client
    struct wl_listener client_uniconify;
    struct wl_listener client_stick;
    struct wl_listener client_unstick;
+   struct wl_listener client_maximize;
+   struct wl_listener client_unmaximize;
 
    // comp_object listeners
    struct wl_listener comp_object_raise;
@@ -538,6 +540,8 @@ _e_desk_area_active_change(E_Desk_Area *eda, E_Desk *desk)
      }
 }
 
+
+
 static void
 _e_desk_area_cb_hook_subsurface_create(void *data, E_Client *ec)
 {
@@ -737,6 +741,8 @@ _e_desk_area_private_client_del(E_Desk_Area_Private_Client *eda_client)
    wl_list_remove(&eda_client->comp_object_lower.link);
    wl_list_remove(&eda_client->comp_object_raise.link);
 
+   wl_list_remove(&eda_client->client_unmaximize.link);
+   wl_list_remove(&eda_client->client_maximize.link);
    wl_list_remove(&eda_client->client_unstick.link);
    wl_list_remove(&eda_client->client_stick.link);
    wl_list_remove(&eda_client->client_uniconify.link);
@@ -1397,6 +1403,282 @@ _desk_area_cb_client_unstick(struct wl_listener *listener, void *data)
 }
 
 static void
+_e_desk_area_ec_maximize(E_Desk_Area *eda, E_Client *ec, E_Maximize max)
+{
+   int x1, yy1, x2, y2;
+//FIXME: TODO: This is ugly. Use the x,y,w,y of this desk_area
+   int zx, zy, zw, zh;
+   Eina_Bool override = ec->maximize_override;
+
+//FIXME: TODO: This is ugly. Use the x,y,w,y of this desk_area
+// Obstacles of zone should be the desk_areas by the window manager policy.
+// If the Obstacles assigns the desk_areas, this maximize callback does not need
+// e_zone_desk_useful_geometry_get() function. Because the geometry of this desk_area
+// already be calcuated by the obstacles desk_areas. Therefore, the zx, zy, zw, zh in
+// this function can use the x,y,w,h of this desk_area.
+   E_Desk *desk;
+   E_Zone *zone;
+   desk = eda->desk;
+   zone = desk->zone;
+
+   zx = zy = zw = zh = 0;
+   ec->maximize_override = 1;
+
+   switch (max & E_MAXIMIZE_TYPE)
+     {
+      case E_MAXIMIZE_NONE:
+         /* Ignore */
+         break;
+
+      case E_MAXIMIZE_FULLSCREEN:
+      case E_MAXIMIZE_FILL:
+         if (ec->base_output_resolution.use)
+           {
+              zx = eda->x;
+              zy = eda->y;
+              zw = ec->base_output_resolution.w;
+              zh = ec->base_output_resolution.h;
+           }
+         else
+           {
+              //FIXME: TODO: This is ugly. Use the x,y,w,y of this desk_area
+              e_zone_desk_useful_geometry_get(zone, desk, &zx, &zy, &zw, &zh, EINA_FALSE);
+           }
+
+         switch (max & E_MAXIMIZE_DIRECTION)
+           {
+            case E_MAXIMIZE_BOTH:
+               e_client_maximized_geometry_set(ec, zx, zy, zw, zh);
+               break;
+
+            case E_MAXIMIZE_VERTICAL:
+               e_client_maximized_geometry_set(ec, ec->x, zy, ec->w, zh);
+               break;
+
+            case E_MAXIMIZE_HORIZONTAL:
+               e_client_maximized_geometry_set(ec, zx, ec->y, zw, ec->h);
+               break;
+
+            case E_MAXIMIZE_LEFT:
+               e_client_maximized_geometry_set(ec, zx, zy, zw / 2, zh);
+               break;
+
+            case E_MAXIMIZE_RIGHT:
+               e_client_maximized_geometry_set(ec, zx + zw / 2, zy, zw / 2, zh);
+               break;
+           }
+         break;
+
+      case E_MAXIMIZE_SMART:
+      case E_MAXIMIZE_EXPAND:
+         if (desk->visible)
+           {
+              // base_output_resolution
+              if (ec->base_output_resolution.use)
+                {
+                   zx = eda->x;
+                   zy = eda->y;
+                   zw = ec->base_output_resolution.w;
+                   zh = ec->base_output_resolution.h;
+                }
+              else
+                {
+                   //FIXME: TODO: This is ugly. Use the x,y,w,y of this desk_area
+                   e_zone_desk_useful_geometry_get(zone, desk, &zx, &zy, &zw, &zh, EINA_TRUE);
+                }
+           }
+         else
+           {
+              x1 = eda->x;
+              yy1 = eda->y;
+              x2 = eda->x + eda->w;
+              y2 = eda->y + eda->h;
+              e_maximize_client_shelf_fill(ec, &x1, &yy1, &x2, &y2, max);
+              zx = x1, zy = yy1;
+              zw = x2 - x1;
+              zh = y2 - yy1;
+           }
+
+         evas_object_smart_callback_call(ec->frame, "maximize", NULL);
+
+         switch (max & E_MAXIMIZE_DIRECTION)
+           {
+            case E_MAXIMIZE_BOTH:
+               e_client_maximized_geometry_set(ec, zx, zy, zw, zh);
+               break;
+
+            case E_MAXIMIZE_VERTICAL:
+               e_client_maximized_geometry_set(ec, ec->x, zy, ec->w, zh);
+               break;
+
+            case E_MAXIMIZE_HORIZONTAL:
+               e_client_maximized_geometry_set(ec, zx, ec->y, zw, ec->h);
+               break;
+
+            case E_MAXIMIZE_LEFT:
+               e_client_maximized_geometry_set(ec, zx, zy, zw / 2, zh);
+               break;
+
+            case E_MAXIMIZE_RIGHT:
+               e_client_maximized_geometry_set(ec, zx + zw / 2, zy, zw / 2, zh);
+               break;
+           }
+         break;
+     }
+
+   if (ec->maximize_override)
+     ec->maximize_override = override;
+}
+
+static void
+_desk_area_cb_client_maximize(struct wl_listener *listener, void *data)
+{
+   E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
+   E_Client *ec;
+   E_Maximize max;
+
+   eda_client = wl_container_of(listener, eda_client, client_maximize);
+   eda = eda_client->eda;
+   ec = eda_client->ec;
+
+   max = *((E_Maximize *)data);
+
+   ec->pre_res_change.valid = 0;
+
+   if (!ec->fullscreen)
+     {
+        evas_object_smart_callback_call(ec->frame, "maximize_pre", NULL);
+
+        if (!(ec->maximized & E_MAXIMIZE_HORIZONTAL))
+          {
+             /* Horizontal hasn't been set */
+             ec->saved.x = ec->client.x - eda->x;
+             ec->saved.w = ec->client.w;
+          }
+        if (!(ec->maximized & E_MAXIMIZE_VERTICAL))
+          {
+             /* Vertical hasn't been set */
+             ec->saved.y = ec->client.y - eda->y;
+             ec->saved.h = ec->client.h;
+          }
+
+        _e_desk_area_ec_maximize(eda, ec, max);
+     }
+}
+
+static void
+_desk_area_cb_client_unmaximize(struct wl_listener *listener, void *data)
+{
+   E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
+   E_Client *ec;
+   E_Maximize max;
+
+   eda_client = wl_container_of(listener, eda_client, client_unmaximize);
+   eda = eda_client->eda;
+   ec = eda_client->ec;
+
+   if (ec->fullscreen) return;
+
+   max = *((E_Maximize *)data);
+
+   if (ec->maximized & E_MAXIMIZE_TYPE)
+     {
+        ec->pre_res_change.valid = 0;
+        ec->changes.need_maximize = 0;
+
+        if ((ec->maximized & E_MAXIMIZE_TYPE) == E_MAXIMIZE_FULLSCREEN)
+          {
+             E_Maximize tmp_max = ec->maximized;
+
+             //un-set maximized state for updating frame.
+             ec->maximized = E_MAXIMIZE_NONE;
+             e_client_frame_update(ec);
+             // re-set maximized state for unmaximize smart callback.
+             ec->maximized = tmp_max;
+             evas_object_smart_callback_call(ec->frame, "unfullscreen", NULL);
+             // un-set maximized state.
+             ec->maximized = E_MAXIMIZE_NONE;
+             e_client_util_move_resize_without_frame(ec,
+                                                     ec->saved.x + eda->x,
+                                                     ec->saved.y + eda->y,
+                                                     ec->saved.w, ec->saved.h);
+             ec->saved.x = ec->saved.y = ec->saved.w = ec->saved.h = 0;
+          }
+        else
+          {
+             int w, h, x, y;
+             Eina_Bool horiz = EINA_FALSE, vert = EINA_FALSE;
+
+             w = ec->client.w;
+             h = ec->client.h;
+             x = ec->client.x;
+             y = ec->client.y;
+
+             if (max & E_MAXIMIZE_VERTICAL)
+               {
+                  /* Remove vertical */
+                  h = ec->saved.h;
+                  vert = EINA_TRUE;
+                  y = ec->saved.y + eda->y;
+                  if ((max & E_MAXIMIZE_VERTICAL) == E_MAXIMIZE_VERTICAL)
+                    {
+                       ec->maximized &= ~E_MAXIMIZE_VERTICAL;
+                       ec->maximized &= ~E_MAXIMIZE_LEFT;
+                       ec->maximized &= ~E_MAXIMIZE_RIGHT;
+                    }
+                  if ((max & E_MAXIMIZE_LEFT) == E_MAXIMIZE_LEFT)
+                    ec->maximized &= ~E_MAXIMIZE_LEFT;
+                  if ((max & E_MAXIMIZE_RIGHT) == E_MAXIMIZE_RIGHT)
+                    ec->maximized &= ~E_MAXIMIZE_RIGHT;
+               }
+             if (max & E_MAXIMIZE_HORIZONTAL)
+               {
+                  /* Remove horizontal */
+                  w = ec->saved.w;
+                  x = ec->saved.x + eda->x;
+                  horiz = EINA_TRUE;
+                  ec->maximized &= ~E_MAXIMIZE_HORIZONTAL;
+               }
+
+             if (!(ec->maximized & E_MAXIMIZE_DIRECTION))
+               {
+                  ec->maximized = E_MAXIMIZE_NONE;
+                  e_client_frame_update(ec);
+                  evas_object_smart_callback_call(ec->frame, "unmaximize", NULL);
+                  e_client_resize_limit(ec, &w, &h);
+                  e_client_pos_set(ec, x, y);
+                  if ((ec->saved.w != 0) && (ec->saved.h != 0))
+                    {
+                       if ((w != ec->saved.w) || (h != ec->saved.h))
+                         {
+                            e_policy_visibility_client_defer_move(ec);
+                         }
+                    }
+               }
+             else
+               {
+                  evas_object_smart_callback_call(ec->frame, "unmaximize", NULL);
+                  e_client_resize_limit(ec, &w, &h);
+                  e_client_pos_set(ec, x, y);
+                  if ((ec->saved.w != 0) && (ec->saved.h != 0))
+                    {
+                       if ((w != ec->saved.w) || (h != ec->saved.h))
+                         {
+                            e_policy_visibility_client_defer_move(ec);
+                         }
+                    }
+               }
+             if (vert)
+               ec->saved.h = ec->saved.y = 0;
+             if (horiz)
+               ec->saved.w = ec->saved.x = 0;
+          }
+     }
+}
+
+static void
 _desk_area_cb_comp_object_lower(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
@@ -2054,6 +2336,10 @@ e_desk_area_ec_add(E_Desk_Area *eda, E_Client *ec)
    e_client_stick_listener_add(ec, &eda_client->client_stick);
    eda_client->client_unstick.notify = _desk_area_cb_client_unstick;
    e_client_unstick_listener_add(ec, &eda_client->client_unstick);
+   eda_client->client_maximize.notify = _desk_area_cb_client_maximize;
+   e_client_maximize_listener_add(ec, &eda_client->client_maximize);
+   eda_client->client_unmaximize.notify = _desk_area_cb_client_unmaximize;
+   e_client_unmaximize_listener_add(ec, &eda_client->client_unmaximize);
 
    // e_comp_object listeners
    eda_client->comp_object_lower.notify = _desk_area_cb_comp_object_lower;

diff --git a/src/bin/e_zone.c b/src/bin/e_zone.c
index 7f9af31..4a82184 100644 (file)
--- a/src/bin/e_zone.c
+++ b/src/bin/e_zone.c
@@ -50,9 +50,9 @@ struct _E_Zone_Private_Client
    struct wl_listener client_uniconify;
    struct wl_listener client_stick;
    struct wl_listener client_unstick;
-#endif
    struct wl_listener client_maximize;
    struct wl_listener client_unmaximize;
+#endif
    struct wl_listener client_activate_done;
 #ifdef REFACTOR_DESK_AREA
 #else
@@ -170,6 +170,8 @@ e_zone_shutdown(void)
    return 1;
 }
 
+#ifdef REFACTOR_DESK_AREA
+#else
 static void
 _e_zone_client_maximize(E_Zone *zone, E_Desk *desk, E_Client *ec, E_Maximize max)
 {
@@ -181,12 +183,6 @@ _e_zone_client_maximize(E_Zone *zone, E_Desk *desk, E_Client *ec, E_Maximize max
    zx = zy = zw = zh = 0;
    ec->maximize_override = 1;
 
-#ifdef REFACTOR_DESK_AREA
-   desk_x = desk->geom.x;
-   desk_y = desk->geom.y;
-   desk_w = desk->geom.w;
-   desk_h = desk->geom.h;
-#else
    if (ec->desk_area.enable && ec->desk_area.desk_area)
      {
         desk_x = ec->desk_area.desk_area->x;
@@ -201,7 +197,6 @@ _e_zone_client_maximize(E_Zone *zone, E_Desk *desk, E_Client *ec, E_Maximize max
         desk_w = desk->geom.w;
         desk_h = desk->geom.h;
      }
-#endif
 
    switch (max & E_MAXIMIZE_TYPE)
      {
@@ -306,6 +301,7 @@ _e_zone_client_maximize(E_Zone *zone, E_Desk *desk, E_Client *ec, E_Maximize max
    if (ec->maximize_override)
      ec->maximize_override = override;
 }
+#endif
 
 static void
 _e_zone_client_apply_auto_placement(E_Zone *zone, E_Client *ec)
@@ -431,10 +427,10 @@ _zone_cb_client_destroy(struct wl_listener *listener, void *data)
    wl_list_remove(&zone_client->client_fullscreen.link);
 #endif
    wl_list_remove(&zone_client->client_activate_done.link);
-   wl_list_remove(&zone_client->client_unmaximize.link);
-   wl_list_remove(&zone_client->client_maximize.link);
 #ifdef REFACTOR_DESK_AREA
 #else
+   wl_list_remove(&zone_client->client_unmaximize.link);
+   wl_list_remove(&zone_client->client_maximize.link);
    wl_list_remove(&zone_client->client_unstick.link);
    wl_list_remove(&zone_client->client_stick.link);
    wl_list_remove(&zone_client->client_uniconify.link);
@@ -847,7 +843,6 @@ _zone_cb_client_unstick(struct wl_listener *listener, void *data)
           }
      }
 }
-#endif
 
 static void
 _zone_cb_client_maximize(struct wl_listener *listener, void *data)
@@ -868,10 +863,6 @@ _zone_cb_client_maximize(struct wl_listener *listener, void *data)
    desk = e_zone_desk_find_by_ec(zone, ec);
    EINA_SAFETY_ON_NULL_RETURN(desk);
 
-#ifdef REFACTOR_DESK_AREA
-   desk_x = desk->geom.x;
-   desk_y = desk->geom.y;
-#else
    if (ec->desk_area.enable && ec->desk_area.desk_area)
      {
         desk_x = ec->desk_area.desk_area->x;
@@ -882,7 +873,7 @@ _zone_cb_client_maximize(struct wl_listener *listener, void *data)
         desk_x = desk->geom.x;
         desk_y = desk->geom.y;
      }
-#endif
+
    ec->pre_res_change.valid = 0;
 
    if (!ec->fullscreen)
@@ -1017,8 +1008,8 @@ _zone_cb_client_unmaximize(struct wl_listener *listener, void *data)
                ec->saved.w = ec->saved.x = 0;
           }
      }
-
 }
+#endif
 
 static void
 _zone_cb_client_activate_done(struct wl_listener *listener, void *data)
@@ -2280,13 +2271,13 @@ e_zone_client_add(E_Zone *zone, E_Client *ec)
 
    zone_client->client_unstick.notify = _zone_cb_client_unstick;
    e_client_unstick_listener_add(ec, &zone_client->client_unstick);
-#endif
 
    zone_client->client_maximize.notify = _zone_cb_client_maximize;
    e_client_maximize_listener_add(ec, &zone_client->client_maximize);
 
    zone_client->client_unmaximize.notify = _zone_cb_client_unmaximize;
    e_client_unmaximize_listener_add(ec, &zone_client->client_unmaximize);
+#endif
 
    zone_client->client_activate_done.notify = _zone_cb_client_activate_done;
    e_client_activate_done_listener_add(ec, &zone_client->client_activate_done);