From 5b3d0440c674f7684370ff8a6c6ea255a945c8f9 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Sun, 24 Dec 2023 10:59:01 +0900 Subject: [PATCH] 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 --- src/bin/e_desk_area.c | 286 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/bin/e_zone.c | 27 ++--- 2 files changed, 295 insertions(+), 18 deletions(-) diff --git a/src/bin/e_desk_area.c b/src/bin/e_desk_area.c index 40f19db..55aa260 100644 --- 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 --- 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); -- 2.7.4