-#include "e.h"
#include "e_client_intern.h"
+#include "e_actions_intern.h"
+#include "e_appinfo_intern.h"
+#include "e_bindings_intern.h"
+#include "e_uuid_store_intern.h"
+#include "e_utils_intern.h"
+#include "e_comp_canvas_intern.h"
+#include "e_comp_wl_intern.h"
+#include "e_comp_wl_subsurface_intern.h"
+#include "e_comp_intern.h"
+#include "e_input_intern.h"
+#include "e_policy_intern.h"
+#include "e_map_intern.h"
+#include "e_policy_visibility_intern.h"
+#include "e_comp_object_intern.h"
+#include "e_desk_area_intern.h"
+#include "e_desk_intern.h"
+#include "e_zone_intern.h"
+#include "e_config_intern.h"
+#include "e_input_thread_client_intern.h"
#define PRI(ec) ((E_Client_Private *)e_object_data_get(E_OBJECT(ec)))
#define API_ENTRY \
EINA_SAFETY_ON_NULL_RETURN(ec); \
- E_Client_Private *priv = PRI(ec)
+ E_Client_Private *priv = PRI(ec); \
+ EINA_SAFETY_ON_NULL_RETURN(priv);
#define API_ENTRY_VAL(ret) \
EINA_SAFETY_ON_NULL_RETURN_VAL(ec, ret); \
- E_Client_Private *priv = PRI(ec)
+ E_Client_Private *priv = PRI(ec); \
+ EINA_SAFETY_ON_NULL_RETURN_VAL(priv, ret);
typedef struct _E_Client_Private E_Client_Private;
{
struct
{
+ struct wl_signal eval_pre_fetch;
+ struct wl_signal eval_fetch;
+ struct wl_signal eval_pre_post_fetch;
+ struct wl_signal eval_post_fetch;
+ struct wl_signal eval_pre_frame_assign;
+ struct wl_signal eval_post_frame_assign;
+ struct wl_signal eval_pre_new_client;
+ struct wl_signal eval_post_new_client;
+ struct wl_signal eval_visibility;
+ struct wl_signal eval_visibility_end;
+ struct wl_signal eval_end;
+
+ struct wl_signal move_begin;
+ struct wl_signal move_update;
+ struct wl_signal move_end;
+ struct wl_signal move_resize_begin;
+ struct wl_signal move_resize_update;
+ struct wl_signal move_resize_end;
+
struct wl_signal destroy;
+ struct wl_signal new_client;
+ struct wl_signal new_client_post;
+
+ struct wl_signal unredirect;
+ struct wl_signal redirect;
+
+ struct wl_signal aux_hint_change;
+ struct wl_signal window_role_change;
+ struct wl_signal transform_change;
+ struct wl_signal activate_done;
+
+ struct wl_signal mouse_in;
+ struct wl_signal mouse_out;
+ struct wl_signal mouse_down;
+
+ struct wl_signal focus_set;
+ struct wl_signal focus_unset;
+ struct wl_signal focus_defer_set;
+ struct wl_signal focus_latest_set;
+
+ struct wl_signal iconify;
+ struct wl_signal uniconify;
+ struct wl_signal maximize;
+ struct wl_signal unmaximize;
+ struct wl_signal fullscreen_pre;
+ struct wl_signal fullscreen;
+ struct wl_signal unfullscreen;
+
+ struct wl_signal move;
+
+ struct wl_signal set_layer;
+ struct wl_signal raise;
+ struct wl_signal lower;
+ struct wl_signal stack_below;
+ struct wl_signal stack_above;
+ struct wl_signal stack_transient_for_done;
+
+ struct wl_signal stick;
+ struct wl_signal unstick;
+
+#ifdef REFACTOR_DESK_AREA
+ struct wl_signal get_above;
+ struct wl_signal get_below;
+ struct wl_signal get_visible_above;
+ struct wl_signal get_visible_below;
+ struct wl_signal subsurface_stack_update;
+#endif
} events;
+
+ Eina_Bool hide_by_request;
+ Eina_Bool focus_check;
+
+ E_Client *modal;
};
static int _e_client_hooks_delete = 0;
static Eina_Hash *clients_hash[E_PIXMAP_TYPE_MAX] = {NULL}; // pixmap->client
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-static E_Client *focused = NULL;
-#endif
static E_Client *ecmove = NULL;
static E_Client *ecresize = NULL;
static E_Client *action_client = NULL;
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-static Eina_List *focus_stack = NULL;
-static Eina_List *defer_focus_stack = NULL;
-#endif
-
static Eina_Bool comp_grabbed = EINA_FALSE;
static Eina_List *handlers = NULL;
static Eina_List *hooks = NULL;
+static Eina_List *comp_hooks = NULL;
static Ecore_Event_Handler *action_handler_mouse = NULL;
static Ecore_Timer *action_timer = NULL;
static E_Client_Resize_Object_Create_Cb _e_client_resize_object_create_cb = NULL;
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-static GMutex focused_ec_mutex;
-#endif
-
EINTERN void e_client_focused_set(E_Client *ec);
static void _e_client_transient_for_group_make(E_Client *ec, Eina_List **list);
static Evas_Object *_e_client_resize_object_create(E_Client *ec);
[E_CLIENT_HOOK_FOCUS_SET] = NULL,
[E_CLIENT_HOOK_FOCUS_UNSET] = NULL,
[E_CLIENT_HOOK_NEW_CLIENT] = NULL,
-//#ifdef REFACTOR_ZONE_DESK
-//#else
- [E_CLIENT_HOOK_DESK_SET] = NULL,
-//#endif
[E_CLIENT_HOOK_MOVE_BEGIN] = NULL,
[E_CLIENT_HOOK_MOVE_UPDATE] = NULL,
[E_CLIENT_HOOK_MOVE_END] = NULL,
[E_CLIENT_HOOK_RESIZE_UPDATE] = NULL,
[E_CLIENT_HOOK_RESIZE_END] = NULL,
[E_CLIENT_HOOK_FULLSCREEN_PRE] = NULL,
-//#ifdef REFACTOR_ZONE_DESK
- [E_CLIENT_HOOK_FULLSCREEN] = NULL,
- [E_CLIENT_HOOK_UNFULLSCREEN] = NULL,
-//#endif
[E_CLIENT_HOOK_DEL] = NULL,
[E_CLIENT_HOOK_UNREDIRECT] = NULL,
[E_CLIENT_HOOK_REDIRECT] = NULL,
[E_CLIENT_HOOK_TRANSFORM_CHANGE] = NULL,
[E_CLIENT_HOOK_ACTIVATE_DONE] = NULL,
[E_CLIENT_HOOK_EVAL_VISIBILITY_END] = NULL,
-//#ifdef REFACTOR_FOCUS_POLICY
- [E_CLIENT_HOOK_MOUSE_IN] = NULL,
- [E_CLIENT_HOOK_MOUSE_OUT] = NULL,
- [E_CLIENT_HOOK_MOUSE_DOWN] = NULL,
- [E_CLIENT_HOOK_LOWER] = NULL,
- [E_CLIENT_HOOK_MOVE] = NULL,
- [E_CLIENT_HOOK_FOCUS_DEFER_SET] = NULL,
- [E_CLIENT_HOOK_FOCUS_LATEST_SET] = NULL,
-//#endif
-//#ifdef REFACTOR_ZONE_DESK
- [E_CLIENT_HOOK_STICK] = NULL,
- [E_CLIENT_HOOK_UNSTICK] = NULL,
- [E_CLIENT_HOOK_MAXIMIZE] = NULL,
- [E_CLIENT_HOOK_UNMAXIMIZE] = NULL,
-//#endif
};
static Eina_Inlist *_e_client_intercept_hooks[] =
ecore_event_add(E_EVENT_CLIENT_PROPERTY, ev, (Ecore_End_Cb)_e_client_event_simple_free, NULL);
}
-#ifdef REFACTOR_ZONE_DESK
-#else
-static void
-_e_client_event_desk_set_free(void *d EINA_UNUSED, E_Event_Client_Desk_Set *ev)
-{
- UNREFD(ev->ec, 4);
- e_object_unref(E_OBJECT(ev->ec));
- e_object_unref(E_OBJECT(ev->desk));
- free(ev);
-}
-
-static void
-_e_client_event_zone_set_free(void *d EINA_UNUSED, E_Event_Client_Zone_Set *ev)
-{
- UNREFD(ev->ec, 5);
- e_object_unref(E_OBJECT(ev->ec));
- e_object_unref(E_OBJECT(ev->zone));
- free(ev);
-}
-#endif
////////////////////////////////////////////////
static int
(e_client_is_iconified_by_client(ec)));
}
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-static Eina_Bool
-_e_client_focus_can_take_by_vis_obscured(E_Client *ec)
-{
- switch (ec->visibility.obscured)
- {
- case E_VISIBILITY_UNKNOWN:
- if (e_client_check_really_iconified(ec))
- return EINA_FALSE;
-
- if (!evas_object_visible_get(ec->frame) &&
- !eina_list_data_find(defer_focus_stack, ec))
- return EINA_FALSE;
- break;
-
- case E_VISIBILITY_FULLY_OBSCURED:
- if (e_client_check_really_iconified(ec))
- return EINA_FALSE;
-
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK)
- {
- if (!evas_object_visible_get(ec->frame))
- {
- ELOGF("FOCUS", "client is hidden, skip focus", ec);
- return EINA_FALSE;
- }
- }
- break;
-
- case E_VISIBILITY_UNOBSCURED:
- case E_VISIBILITY_PARTIALLY_OBSCURED:
- case E_VISIBILITY_PRE_UNOBSCURED:
- default:
- break;
- }
- return EINA_TRUE;
-}
-
-static Eina_Bool
-_e_client_focus_can_take(E_Client *ec)
-{
- E_Zone *zone = NULL;
- E_Client *child_ec = NULL;
- E_Client *above_ec = NULL;
- int x = 0, y = 0, w = 0, h = 0;
-
- if (!ec) return EINA_FALSE;
- if (e_object_is_del(E_OBJECT(ec))) return EINA_FALSE;
- if (e_client_util_ignored_get(ec)) return EINA_FALSE;
-
- if (!(ec->icccm.accepts_focus || ec->icccm.take_focus)) return EINA_FALSE;
- if (ec->lock_focus_in || ec->lock_focus_out) return EINA_FALSE;
-
- if (!ec->visible) return EINA_FALSE;
- if (ec->bg_state) return EINA_FALSE;
- if (ec->visibility.force_obscured) return EINA_FALSE;
- if (!_e_client_focus_can_take_by_vis_obscured(ec)) return EINA_FALSE;
-
- zone = e_comp_zone_find_by_ec(ec);
- if (zone)
- {
- e_client_geometry_get(ec, &x, &y, &w, &h);
- if (!E_INTERSECTS(zone->x, zone->y, zone->w, zone->h, x, y, w, h))
- return EINA_FALSE;
- }
-
- above_ec = e_client_check_fully_contain_by_above(ec, EINA_FALSE);
- if (above_ec)
- {
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK)
- {
- if (!evas_object_visible_get(above_ec->frame))
- return EINA_TRUE;
- }
-
- child_ec = e_client_check_obscured_by_children_group(ec);
- if (!child_ec) return EINA_FALSE;
- if (above_ec != child_ec) return EINA_FALSE;
-
- if (_e_client_focus_can_take(child_ec))
- return EINA_FALSE;
- else if (e_client_check_fully_contain_by_above(child_ec, EINA_FALSE))
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-EINTERN Eina_Bool
-e_client_focus_can_take(E_Client *ec)
-{
- return _e_client_focus_can_take(ec);
-}
-
-static E_Client *
-_e_client_focus_topmost_focusable_get(void)
-{
- E_Client *ec = NULL;
-
- E_CLIENT_REVERSE_FOREACH(ec)
- {
- if (_e_client_focus_can_take(ec))
- return ec;
- }
- return NULL;
-}
-
-static E_Client *
-_e_client_find_next_focus(E_Client *ec)
-{
- Eina_List *l = NULL;
- E_Client *temp_ec = NULL;
-
- // call the intercept hook of the revert focus
- if (e_client_intercept_hook_focus_revert_call(ec))
- return NULL;
-
- EINA_LIST_FOREACH(focus_stack, l, temp_ec)
- {
- if (_e_client_focus_can_take(temp_ec))
- return temp_ec;
- }
-
- return NULL;
-}
-
-static E_Client *
-_e_client_revert_focus_get(E_Client *ec)
-{
- E_Client *pec = NULL, *focus_ec = NULL;
- E_Zone *zone;
- E_Desk *desk = NULL;
-
- if (stopping) return NULL;
- if (!ec)
- return _e_client_find_next_focus(NULL);
-
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return NULL;
- desk = e_desk_current_get(zone);
- if (!desk) return NULL;
- if (!e_comp_client_zone_is_displaying(ec)) return NULL;
-
- if (e_config->focus_policy == E_FOCUS_MOUSE)
- {
- // set mouse over focus
- pec = e_client_under_pointer_get(desk, ec);
- if (pec)
- focus_ec = pec;
- /* no autoraise/revert here because it's probably annoying */
- }
- else
- focus_ec = _e_client_find_next_focus(ec);
-
- return focus_ec;
-}
-#endif
-
static void
_e_client_event_focus_skip_set(E_Client *ec, Eina_Bool by_client)
{
}
}
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-EINTERN void
-e_client_revert_focus(E_Client *ec)
-{
- E_Client *focus_ec = NULL;
-
- // check topmost focus policy
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK)
- {
- focus_ec = _e_client_focus_topmost_focusable_get();
- if (focused == focus_ec) return;
-
- if (focus_ec)
- {
- if (!focus_ec->iconic || focus_ec->exp_iconify.buffer_flush)
- {
- ELOGF("FOCUS", "focus set | topmost_focus", focus_ec);
- if (focused) e_client_frame_focus_set(focused, EINA_FALSE);
- e_client_frame_focus_set(focus_ec, EINA_TRUE);
- }
- }
- else
- {
- ELOGF("FOCUS", "focus unset | No focusable ec", focused);
- e_client_frame_focus_set(focused, EINA_FALSE);
- }
-
- return;
- }
-
- focus_ec = _e_client_revert_focus_get(ec);
- if (!focus_ec) return;
-
- if (focus_ec != ec)
- {
- e_client_focus_defer_unset(ec);
- ELOGF("FOCUS", "focus unset | revert_focus", ec);
- e_client_frame_focus_set(ec, EINA_FALSE);
- }
-
- if (!focus_ec->iconic || focus_ec->exp_iconify.buffer_flush)
- {
- ELOGF("FOCUS", "focus set | revert_focus", focus_ec);
- e_client_frame_focus_set(focus_ec, EINA_TRUE);
- }
-}
-#endif
-
EINTERN Eina_Bool
e_client_check_above_focused(E_Client *ec)
{
if (!priv)
return EINA_FALSE;
+ wl_signal_init(&priv->events.eval_pre_fetch);
+ wl_signal_init(&priv->events.eval_fetch);
+ wl_signal_init(&priv->events.eval_pre_post_fetch);
+ wl_signal_init(&priv->events.eval_post_fetch);
+ wl_signal_init(&priv->events.eval_pre_frame_assign);
+ wl_signal_init(&priv->events.eval_post_frame_assign);
+ wl_signal_init(&priv->events.eval_pre_new_client);
+ wl_signal_init(&priv->events.eval_post_new_client);
+ wl_signal_init(&priv->events.eval_visibility);
+ wl_signal_init(&priv->events.eval_visibility_end);
+ wl_signal_init(&priv->events.eval_end);
+ wl_signal_init(&priv->events.move_begin);
+ wl_signal_init(&priv->events.move_update);
+ wl_signal_init(&priv->events.move_end);
+ wl_signal_init(&priv->events.move_resize_begin);
+ wl_signal_init(&priv->events.move_resize_update);
+ wl_signal_init(&priv->events.move_resize_end);
wl_signal_init(&priv->events.destroy);
+ wl_signal_init(&priv->events.new_client);
+ wl_signal_init(&priv->events.new_client_post);
+ wl_signal_init(&priv->events.unredirect);
+ wl_signal_init(&priv->events.redirect);
+ wl_signal_init(&priv->events.aux_hint_change);
+ wl_signal_init(&priv->events.window_role_change);
+ wl_signal_init(&priv->events.transform_change);
+ wl_signal_init(&priv->events.activate_done);
+ wl_signal_init(&priv->events.mouse_in);
+ wl_signal_init(&priv->events.mouse_out);
+ wl_signal_init(&priv->events.mouse_down);
+ wl_signal_init(&priv->events.focus_set);
+ wl_signal_init(&priv->events.focus_unset);
+ wl_signal_init(&priv->events.focus_defer_set);
+ wl_signal_init(&priv->events.focus_latest_set);
+ wl_signal_init(&priv->events.iconify);
+ wl_signal_init(&priv->events.uniconify);
+ wl_signal_init(&priv->events.maximize);
+ wl_signal_init(&priv->events.unmaximize);
+ wl_signal_init(&priv->events.fullscreen_pre);
+ wl_signal_init(&priv->events.fullscreen);
+ wl_signal_init(&priv->events.unfullscreen);
+ wl_signal_init(&priv->events.move);
+ wl_signal_init(&priv->events.set_layer);
+ wl_signal_init(&priv->events.raise);
+ wl_signal_init(&priv->events.lower);
+ wl_signal_init(&priv->events.stack_below);
+ wl_signal_init(&priv->events.stack_above);
+ wl_signal_init(&priv->events.stack_transient_for_done);
+ wl_signal_init(&priv->events.stick);
+ wl_signal_init(&priv->events.unstick);
+#ifdef REFACTOR_DESK_AREA
+ wl_signal_init(&priv->events.get_above);
+ wl_signal_init(&priv->events.get_below);
+ wl_signal_init(&priv->events.get_visible_above);
+ wl_signal_init(&priv->events.get_visible_below);
+ wl_signal_init(&priv->events.subsurface_stack_update);
+#endif
e_object_data_set(E_OBJECT(ec), priv);
}
static void
+_e_input_thread_client_free(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec: %p\n", __func__, ec_data->ec);
+ e_input_thread_client_free(e_input_thread_client_get(ec_data->ec));
+}
+
+static void
_e_client_free(E_Client *ec)
{
+ g_rec_mutex_lock(&e_comp->ec_list_mutex);
+
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
e_comp_object_redirected_set(ec->frame, 0);
e_comp_object_render_update_del(ec->frame);
E_OBJECT(ec)->references++;
-#ifdef REFACTOR_ZONE_DESK
-#else
- if (ec->fullscreen)
- {
- ec->desk->fullscreen_clients = eina_list_remove(ec->desk->fullscreen_clients, ec);
- if (!ec->desk->fullscreen_clients)
- e_comp_render_queue();
- }
-#endif
+
if (ec->new_client)
e_comp->new_clients--;
tmp->e.state.video_parent_client = NULL;
}
E_FREE_FUNC(ec->kill_timer, ecore_timer_del);
- E_FREE_LIST(ec->pending_resize, free);
E_FREE_FUNC(ec->map_timer, ecore_timer_del);
ec->transients = eina_list_free(ec->transients);
- if (ec->netwm.icons)
- {
- int i;
- for (i = 0; i < ec->netwm.num_icons; i++)
- free(ec->netwm.icons[i].data);
- E_FREE(ec->netwm.icons);
- }
- E_FREE(ec->netwm.extra_types);
eina_stringshare_replace(&ec->border.name, NULL);
eina_stringshare_replace(&ec->bordername, NULL);
eina_stringshare_replace(&ec->icccm.name, NULL);
#else
eina_stringshare_replace(&ec->icccm.class, NULL);
#endif
- eina_stringshare_replace(&ec->icccm.title, NULL);
- eina_stringshare_replace(&ec->icccm.icon_name, NULL);
- eina_stringshare_replace(&ec->icccm.machine, NULL);
+ e_client_icccm_title_set(ec, NULL);
eina_stringshare_replace(&ec->icccm.window_role, NULL);
- if ((ec->icccm.command.argc > 0) && (ec->icccm.command.argv))
- {
- int i;
-
- for (i = 0; i < ec->icccm.command.argc; i++)
- free(ec->icccm.command.argv[i]);
- E_FREE(ec->icccm.command.argv);
- }
- eina_stringshare_replace(&ec->netwm.name, NULL);
- eina_stringshare_replace(&ec->netwm.icon_name, NULL);
- eina_stringshare_replace(&ec->internal_icon, NULL);
- eina_stringshare_replace(&ec->internal_icon_key, NULL);
-
-#ifdef REFACTOR_FOCUS_POLICY
- // This code is executed at E_CLIENT_HOOK_DEL callback at e_focus_policy_history.c
-#else
- focus_stack = eina_list_remove(focus_stack, ec);
- e_client_focus_defer_unset(ec);
-#endif
+ e_client_netwm_name_set(ec, NULL);
E_FREE_FUNC(ec->frame, evas_object_del);
-#ifdef REFACTOR_FOCUS_POLICY
- // This code is executed at E_CLIENT_HOOK_DEL callback at e_focus_policy_topmost.c and e_focus_policy_history.c
-#else
- if (ec == focused)
- {
- ELOGF("COMP", "CRITICAL. focused is deleted ec.", ec);
- ELOGF("FOCUS", "CLIENT FOCUS_SET", NULL);
- g_mutex_lock(&focused_ec_mutex);
- focused = NULL;
- g_mutex_unlock(&focused_ec_mutex);
- }
-#endif
-
E_OBJECT(ec)->references--;
ELOGF("COMP", "CLIENT FREE", ec);
e_uuid_store_entry_del(ec->uuid);
-#ifdef REFACTOR_ZONE_DESK
-#else
- e_desk_client_del(ec->desk, ec);
-#endif
+
+ ec_data.ec = ec;
+ INF("[%s] ec: %p\n", __func__, ec);
+ e_input_thread_safe_call(_e_input_thread_client_free, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
_e_client_private_finish(ec);
free(ec);
+
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+}
+
+static void
+_e_input_thread_client_del(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec: %p\n", __func__, ec_data->ec);
+ e_input_thread_client_del(e_input_thread_client_get(ec_data->ec));
}
static void
{
E_Client *child;
E_Pixmap_Type type;
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ g_rec_mutex_lock(&e_comp->ec_list_mutex);
ec->changed = 0;
-#ifdef REFACTOR_FOCUS_POLICY
- // This code is executed at E_CLIENT_HOOK_DEL callback at e_focus_policy_history.c
-#else
- focus_stack = eina_list_remove(focus_stack, ec);
- e_client_focus_defer_unset(ec);
-#endif
-#ifdef REFACTOR_ZONE_DESK
-#else
- e_desk_visible_client_iconified_list_remove(ec->desk, ec);
-#endif
if (ec == e_comp_object_dim_client_get())
{
INF("[DIM] client deleted\n");
e_client_comp_hidden_set(ec, 1);
evas_object_pass_events_set(ec->frame, 1);
}
-#ifdef REFACTOR_FOCUS_POLICY
- // This code is executed at E_CLIENT_HOOK_DEL callback at e_focus_policy_history.c
-#else
- if (ec->focused)
- e_client_revert_focus(ec);
-#endif
E_FREE_FUNC(ec->ping_poller, ecore_poller_del);
- wl_signal_emit_mutable(&PRI(ec)->events.destroy, ec);
+ wl_signal_emit_mutable(&PRI(ec)->events.destroy, NULL);
/* must be called before parent/child clear */
_e_client_hook_call(E_CLIENT_HOOK_DEL, ec);
if (ec->parent)
{
+ if (e_client_modal_child_get(ec->parent) == ec)
+ e_client_modal_child_set(ec->parent, NULL);
ec->parent->transients = eina_list_remove(ec->parent->transients, ec);
ec->parent = NULL;
}
ec->pixmap = NULL;
// base_output_resolution
- e_client_transform_core_remove(ec, ec->base_output_resolution.transform);
e_util_transform_del(ec->base_output_resolution.transform);
ec->base_output_resolution.transform = NULL;
E_FREE_FUNC(ec->base_output_resolution.hook_subsurf_create, e_comp_wl_hook_del);
-#ifdef REFACTOR_ZONE_DESK
-#else
- // desk_zoom
- e_client_transform_core_remove(ec, ec->desk_zoom.transform);
- e_util_transform_del(ec->desk_zoom.transform);
- ec->desk_zoom.transform = NULL;
- E_FREE_FUNC(ec->desk_zoom.hook_subsurf_create, e_comp_wl_hook_del);
-#endif
-
if (ec->transform_core.transform_list)
{
E_Util_Transform *transform;
ec->transform_core.result.enable = EINA_FALSE;
-#ifdef REFACTOR_ZONE_DESK
-#else
- e_client_desk_area_set(ec, NULL);
- e_util_transform_del(ec->desk_area.transform);
- ec->desk_area.transform = NULL;
-#endif
-
_e_client_resize_object_del(ec);
e_comp_visibility_calculation_set(EINA_TRUE);
+
+ ec_data.ec = ec;
+ INF("[%s] ec: %p\n", __func__, ec);
+ e_input_thread_safe_call(_e_input_thread_client_del, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
}
///////////////////////////////////////////
if (ec->hung)
{
ec->hung = 0;
- evas_object_smart_callback_call(ec->frame, "unhung", NULL);
E_FREE_FUNC(ec->kill_timer, ecore_timer_del);
}
}
if (!ec->hung)
{
ec->hung = 1;
- evas_object_smart_callback_call(ec->frame, "hung", NULL);
/* FIXME: if below dialog is up - hide it now */
}
if (ec->delete_requested)
if (!_e_client_action_input_win_new()) return 0;
ec->moving = 1;
ecmove = ec;
+
+ wl_signal_emit(&PRI(ec)->events.move_begin, NULL);
_e_client_hook_call(E_CLIENT_HOOK_MOVE_BEGIN, ec);
if (!ec->moving)
{
{
ec->moving = 0;
_e_client_action_input_win_del();
+
+ wl_signal_emit(&PRI(ec)->events.move_end, NULL);
_e_client_hook_call(E_CLIENT_HOOK_MOVE_END, ec);
if (ec->transformed)
ec->resize_mode = E_POINTER_RESIZE_NONE;
_e_client_action_input_win_del();
+ wl_signal_emit(&PRI(ec)->events.move_resize_end, NULL);
_e_client_hook_call(E_CLIENT_HOOK_RESIZE_END, ec);
if (ec->transformed)
if (e_client_util_ignored_get(client) || (!e_desk_has_ec(desk, client))) return EINA_TRUE;
if (!evas_object_visible_get(client->frame)) return EINA_TRUE;
if (e_policy_client_is_cursor(client)) return EINA_TRUE;
+ if (e_comp_wl->drag_client == client) return EINA_TRUE;
return EINA_FALSE;
}
}
static E_Client *
-_e_client_input_rect_under_pointer_helper(E_Desk *desk, E_Client *exclude, int x, int y)
-{
- E_Client *ec = NULL, *cec;
- int cx, cy, cw, ch;
-
- E_CLIENT_REVERSE_FOREACH(cec)
- {
- /* If a border was specified which should be excluded from the list
- * (because it will be closed shortly for example), skip */
- if (e_client_util_ignored_get(cec) || (!e_desk_has_ec(desk, cec))) continue;
- if (!evas_object_visible_get(cec->frame)) continue;
- if (e_policy_client_is_cursor(cec)) continue;
- if ((exclude) && (cec == exclude)) continue;
- e_client_geometry_get(cec, &cx, &cy, &cw, &ch);
- if (!E_INSIDE(x, y, cx, cy, cw, ch))
- continue;
- /* If the layer is higher, the position of the window is higher
- * (always on top vs always below) */
- if (ec && (cec->layer <= ec->layer)) continue;
- if (_e_client_position_inside_input_rect(cec, x, y))
- ec = cec;
- }
-
- return ec;
-}
-
-static E_Client *
_e_client_under_pointer_input_helper(E_Desk *desk, int x, int y)
{
E_Client *ec = NULL, *cec;
}
////////////////////////////////////////////////
-#ifdef REFACTOR_ZONE_DESK
-#else
-static void
-_e_client_zone_update(E_Client *ec)
-{
- Eina_List *l;
- E_Zone *zone;
-
- /* still within old zone - leave it there */
- zone = e_comp_zone_find_by_ec(ec);
- if (zone && E_INTERSECTS(ec->x, ec->y, ec->w, ec->h,
- zone->x, zone->y, zone->w, zone->h))
- return;
-
- /* find a new zone */
- EINA_LIST_FOREACH(e_comp->zones, l, zone)
- {
- if (E_INTERSECTS(ec->x, ec->y, ec->w, ec->h,
- zone->x, zone->y, zone->w, zone->h))
- {
- e_client_zone_set(ec, zone);
- return;
- }
- }
-}
-#endif
-////////////////////////////////////////////////
static void
_e_client_transform_core_activate_set(E_Client *ec, Eina_Bool set)
if (set)
{
- ec->transform_core.changed = EINA_TRUE;
- e_client_transform_core_update(ec);
+ if (ec->transform_core.result.enable)
+ e_client_map_enable_set(ec, EINA_TRUE);
}
else
{
if (ec->new_client) return;
_e_client_event_hide(ec);
+ e_client_focus_check_set(ec, EINA_TRUE);
EC_CHANGED(ec);
}
static void
-_e_client_cb_evas_shade_done(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
-{
- E_Client *ec = data;
-
- if (e_object_is_del(data)) return;
-
- ec->shading = 0;
- ec->shaded = !(ec->shaded);
- ec->changes.shaded = 1;
- ec->changes.shading = 1;
- e_client_comp_hidden_set(ec, ec->shaded);
-}
-
-static void
_e_client_cb_evas_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
E_Client *ec = data;
_e_client_event_simple(ec, E_EVENT_CLIENT_MOVE);
-#ifdef REFACTOR_ZONE_DESK
-#else
- _e_client_zone_update(ec);
-#endif
evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
if ((e_config->transient.move) && (ec->transients))
{
}
}
if (ec->moving || (ecmove == ec))
- _e_client_hook_call(E_CLIENT_HOOK_MOVE_UPDATE, ec);
+ {
+ wl_signal_emit(&PRI(ec)->events.move_resize_update, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_MOVE_UPDATE, ec);
+ }
if ((!ec->moving) && (ec->transformed))
{
ec->pre_cb.x = x; ec->pre_cb.y = y;
-#ifdef REFACTOR_FOCUS_POLICY
- // This code is executed at E_CLIENT_HOOK_MOVE callback
- // at e_focus_policy_topmost.c and at e_focus_policy_history.c
-
- _e_client_hook_call(E_CLIENT_HOOK_MOVE, ec);
-#else
- if (ec->focused)
- {
- E_Zone *zone;
- zone = e_comp_zone_find_by_ec(ec);
- if (zone && !E_INTERSECTS(ec->x, ec->y, ec->w, ec->h,
- zone->x, zone->y, zone->w, zone->h))
- {
- e_client_revert_focus(ec);
- }
- }
-#endif
+ wl_signal_emit(&PRI(ec)->events.move, NULL);
e_comp_visibility_calculation_set(EINA_TRUE);
}
_e_client_event_simple(ec, E_EVENT_CLIENT_RESIZE);
-#ifdef REFACTOR_ZONE_DESK
-#else
- _e_client_zone_update(ec);
-#endif
evas_object_geometry_get(ec->frame, &x, &y, &w, &h);
if ((e_config->transient.resize) && (ec->transients))
{
}
if (e_client_util_resizing_get(ec) || (ecresize == ec))
- _e_client_hook_call(E_CLIENT_HOOK_RESIZE_UPDATE, ec);
+ {
+ wl_signal_emit(&PRI(ec)->events.move_resize_update, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_RESIZE_UPDATE, ec);
+ }
ec->pre_cb.w = w; ec->pre_cb.h = h;
e_client_transform_core_update(ec);
_e_client_transform_core_activate_set(ec, EINA_TRUE);
_e_client_event_show(ec);
+
+ e_client_focus_check_set(ec, EINA_TRUE);
EC_CHANGED(ec);
}
}
}
- if (ec->unredirected_single) return;
+
_e_client_event_simple(ec, E_EVENT_CLIENT_STACK);
+ e_client_focus_check_set(ec, EINA_TRUE);
+ EC_CHANGED(ec);
+
e_comp_visibility_calculation_set(EINA_TRUE);
}
////////////////////////////////////////////////
-
-#ifdef REFACTOR_ZONE_DESK
-#else
static void
-_e_client_maximize(E_Client *ec, E_Maximize max)
-{
- int x1, yy1, x2, y2;
- int w, h, pw, ph;
- int zx, zy, zw, zh;
- int ecx, ecy, ecw, ech;
- int desk_x, desk_y, desk_w, desk_h;
- Eina_Bool override = ec->maximize_override;
- E_Zone *zone;
-
- zx = zy = zw = zh = 0;
- ec->maximize_override = 1;
-
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return;
-
- if (ec->desk_area.enable && ec->desk_area.desk_area)
- {
- desk_x = ec->desk_area.desk_area->x;
- desk_y = ec->desk_area.desk_area->y;
- desk_w = ec->desk_area.desk_area->w;
- desk_h = ec->desk_area.desk_area->h;
- }
- else
- {
- desk_x = ec->desk->geom.x;
- desk_y = ec->desk->geom.y;
- desk_w = ec->desk->geom.w;
- desk_h = ec->desk->geom.h;
- }
-
- switch (max & E_MAXIMIZE_TYPE)
- {
- case E_MAXIMIZE_NONE:
- /* Ignore */
- break;
-
- case E_MAXIMIZE_FULLSCREEN:
- w = desk_w;
- h = desk_h;
-
- e_client_resize_limit(ec, &w, &h);
- /* center x-direction */
- x1 = desk_x + (desk_w - w) / 2;
- /* center y-direction */
- yy1 = desk_y + (desk_h - h) / 2;
-
- switch (max & E_MAXIMIZE_DIRECTION)
- {
- case E_MAXIMIZE_BOTH:
- e_client_maximized_geometry_set(ec, x1, yy1, w, h);
- break;
-
- case E_MAXIMIZE_VERTICAL:
- e_client_maximized_geometry_set(ec, ec->x, yy1, ec->w, h);
- break;
-
- case E_MAXIMIZE_HORIZONTAL:
- e_client_maximized_geometry_set(ec, x1, ec->y, w, ec->h);
- break;
-
- case E_MAXIMIZE_LEFT:
- e_client_maximized_geometry_set(ec, desk_x, desk_y, w / 2, h);
- break;
-
- case E_MAXIMIZE_RIGHT:
- e_client_maximized_geometry_set(ec, x1, desk_y, w / 2, h);
- break;
- }
- break;
-
- case E_MAXIMIZE_SMART:
- case E_MAXIMIZE_EXPAND:
- if (ec->desk->visible)
- {
- // base_output_resolution
- if (ec->base_output_resolution.use)
- {
- zx = desk_x;
- zy = desk_y;
- zw = ec->base_output_resolution.w;
- zh = ec->base_output_resolution.h;
- }
- else
- {
- e_zone_desk_useful_geometry_get(zone, ec->desk, &zx, &zy, &zw, &zh, EINA_TRUE);
- }
- }
- else
- {
- x1 = desk_x;
- yy1 = desk_y;
- x2 = desk_x + desk_w;
- y2 = desk_y + desk_h;
- e_maximize_client_shelf_fill(ec, &x1, &yy1, &x2, &y2, max);
- zx = x1, zy = yy1;
- zw = x2 - x1;
- zh = y2 - yy1;
- }
- w = zw, h = zh;
-
- evas_object_smart_callback_call(ec->frame, "maximize", NULL);
- e_comp_object_frame_xy_unadjust(ec->frame, ec->x, ec->y, &ecx, &ecy);
- e_comp_object_frame_wh_unadjust(ec->frame, ec->w, ec->h, &ecw, &ech);
-
- if (ecw < zw)
- w = ecw;
-
- if (ech < zh)
- h = ech;
-
- if (ecx < zx) // window left not useful coordinates
- x1 = zx;
- else if (ecx + ecw > zx + zw) // window right not useful coordinates
- x1 = zx + zw - ecw;
- else // window normal position
- x1 = ecx;
-
- if (ecy < zy) // window top not useful coordinates
- yy1 = zy;
- else if (ecy + ech > zy + zh) // window bottom not useful coordinates
- yy1 = zy + zh - ech;
- else // window normal position
- yy1 = ecy;
-
- 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_FILL:
- x1 = desk_x;
- yy1 = desk_y;
- x2 = desk_x + desk_w;
- y2 = desk_y + desk_h;
-
- /* walk through all shelves */
- e_maximize_client_shelf_fill(ec, &x1, &yy1, &x2, &y2, max);
-
- /* walk through all windows */
- e_maximize_client_client_fill(ec, &x1, &yy1, &x2, &y2, max);
-
- w = x2 - x1;
- h = y2 - yy1;
- pw = w;
- ph = h;
- e_client_resize_limit(ec, &w, &h);
- /* center x-direction */
- x1 = x1 + (pw - w) / 2;
- /* center y-direction */
- yy1 = yy1 + (ph - h) / 2;
-
- switch (max & E_MAXIMIZE_DIRECTION)
- {
- case E_MAXIMIZE_BOTH:
- e_client_maximized_geometry_set(ec, x1, yy1, w, h);
- break;
-
- case E_MAXIMIZE_VERTICAL:
- e_client_maximized_geometry_set(ec, ec->x, yy1, ec->w, h);
- break;
-
- case E_MAXIMIZE_HORIZONTAL:
- e_client_maximized_geometry_set(ec, x1, ec->y, w, ec->h);
- break;
-
- case E_MAXIMIZE_LEFT:
- e_client_maximized_geometry_set(ec, desk_x, desk_y, w / 2, h);
- break;
-
- case E_MAXIMIZE_RIGHT:
- e_client_maximized_geometry_set(ec, x1, desk_y, w / 2, h);
- break;
- }
- break;
- }
- if (ec->maximize_override)
- ec->maximize_override = override;
-}
-#endif
-
-////////////////////////////////////////////////
-static void
-_e_client_aux_hint_eval(E_Client *ec)
+_e_client_aux_hint_eval(E_Client *ec)
{
if (!ec) return;
if (cdata && cdata->aux_hint.changed)
{
+ wl_signal_emit(&PRI(ec)->events.aux_hint_change, NULL);
_e_client_hook_call(E_CLIENT_HOOK_AUX_HINT_CHANGE, ec);
EINA_LIST_FOREACH_SAFE(cdata->aux_hint.hints, l, ll, hint)
}
}
-#ifdef REFACTOR_ZONE_DESK
-#else
-static void
-_e_client_apply_auto_placement(E_Client *ec)
-{
- Eina_List *skiplist = NULL;
- int new_x, new_y, t = 0;
- int type;
- E_Client *parent_ec;
- E_Zone *zone;
-
- // intercept auto placement policy
- if (!_e_client_intercept_hook_call(E_CLIENT_INTERCEPT_HOOK_AUTO_PLACEMENT, ec))
- {
- ELOGF("POL", "Intercepted auto_placement policy.", ec);
- return;
- }
-
- int zx = 0, zy = 0, zw = 0, zh = 0;
-
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return;
-
- e_zone_useful_geometry_get(zone, &zx, &zy, &zw, &zh);
-
- unsigned int seed = (unsigned int)time(NULL);
-
- if (zw > ec->w)
- new_x = zx + (rand_r(&seed) % (zw - ec->w));
- else
- new_x = zx;
- if (zh > ec->h)
- new_y = zy + (rand_r(&seed) % (zh - ec->h));
- else
- new_y = zy;
-
- e_comp_object_frame_geometry_get(ec->frame, NULL, NULL, &t, NULL);
-
- parent_ec = ec->parent;
- if (parent_ec)
- {
- type = 1;
- new_x = parent_ec->x;
- new_y = parent_ec->y;
- }
- else if ((e_config->window_placement_policy == E_WINDOW_PLACEMENT_SMART) || (e_config->window_placement_policy == E_WINDOW_PLACEMENT_ANTIGADGET))
- {
- type = 2;
- skiplist = eina_list_append(skiplist, ec);
- if (ec->desk)
- e_place_desk_region_smart(ec->desk, skiplist,
- ec->x, ec->y, ec->w, ec->h,
- &new_x, &new_y);
- else
- e_place_zone_region_smart(zone, skiplist,
- ec->x, ec->y, ec->w, ec->h,
- &new_x, &new_y);
-
- eina_list_free(skiplist);
- }
- else if (e_config->window_placement_policy == E_WINDOW_PLACEMENT_MANUAL)
- {
- type = 3;
- e_place_zone_manual(zone, ec->w, t, &new_x, &new_y);
- }
- else
- {
- type = 0;
- e_place_zone_cursor(zone, ec->x, ec->y, ec->w, ec->h,
- t, &new_x, &new_y);
- }
-
- ELOGF("POL", "Apply auto placement (type:%d). (%d,%d) -> (%d,%d).", ec, type, ec->x, ec->y, new_x, new_y);
- e_client_pos_set(ec, new_x, new_y);
- ec->changes.pos = 1;
- ec->placed = 1;
- ec->pre_cb.x = ec->x; ec->pre_cb.y = ec->y;
-}
-#endif
-
static void
_e_client_eval(E_Client *ec)
{
int send_event = 1;
unsigned int prop = 0;
-#ifdef REFACTOR_ZONE_DESK
int tx, ty;
-#else
- E_Zone *zone;
- int tx, ty, tw, th;
- int nw, nh;
-#endif
if (e_object_is_del(E_OBJECT(ec)))
{
TRACE_DS_BEGIN(CLIENT:EVAL);
+ wl_signal_emit(&PRI(ec)->events.eval_pre_new_client, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_NEW_CLIENT, ec))
{
TRACE_DS_END();
return;
}
-#ifdef REFACTOR_ZONE_DESK
if ((ec->new_client) && (!e_client_util_ignored_get(ec)))
{
+ wl_signal_emit(&PRI(ec)->events.eval_post_new_client, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_NEW_CLIENT, ec))
{
TRACE_DS_END();
return;
}
}
-#else
- zone = e_comp_zone_find_by_ec(ec);
- if ((ec->new_client) && (!e_client_util_ignored_get(ec)) && (zone))
- {
- int zx = 0, zy = 0, zw = 0, zh = 0;
-
- e_zone_useful_geometry_get(zone, &zx, &zy, &zw, &zh);
- /* enforce wm size hints for initial sizing */
- if (e_config->screen_limits == E_CLIENT_OFFSCREEN_LIMIT_ALLOW_NONE)
- {
- tw = MIN(ec->w, zone->w);
- th = MIN(ec->h, zone->h);
- e_client_size_set(ec, tw, th);
- }
-
- nw = ec->w;
- nh = ec->h;
- e_client_resize_limit(ec, &nw, &nh);
- e_client_size_set(ec, nw, nh);
-
- if (ec->re_manage)
- {
- int x = ec->x, y = ec->y;
- if (ec->x) e_comp_object_frame_xy_adjust(ec->frame, ec->x, 0, &ec->x, NULL);
- if (ec->y) e_comp_object_frame_xy_adjust(ec->frame, 0, ec->y, NULL, &ec->y);
- if ((x != ec->x) || (y != ec->y)) ec->changes.pos = 1;
- ec->placed = 1;
- ec->pre_cb.x = ec->x; ec->pre_cb.y = ec->y;
- }
- if (!ec->placed)
- {
- if (ec->dialog)
- {
- tx = zx + ((zw - ec->w) / 2);
- ty = zy + ((zh - ec->h) / 2);
- e_client_pos_set(ec, tx, ty);
-
- ec->changes.pos = 1;
- ec->placed = 1;
- ec->pre_cb.x = ec->x; ec->pre_cb.y = ec->y;
- }
- }
-
- E_Appinfo *eai;
- eai = e_appinfo_find_with_pid(ec->netwm.pid);
- if (!eai)
- {
- if (!ec->placed)
- _e_client_apply_auto_placement(ec);
- }
- else
- {
- if (e_appinfo_auto_placement_get(eai))
- _e_client_apply_auto_placement(ec);
- }
-
- /* Recreate state */
- if (ec->e.state.centered)
- {
- tx = zx + (zw - ec->w) / 2;
- ty = zy + (zh - ec->h) / 2;
- e_client_pos_set(ec, tx, ty);
- ec->changes.pos = 1;
- }
-
- /* if the explicit geometry request asks for the app to be
- * in another zone - well move it there */
- {
- E_Zone *zone1 = NULL;
- int x, y;
-
- x = MAX(ec->x, 0);
- y = MAX(ec->y, 0);
- if ((!ec->re_manage) && ((ec->x != x) || (ec->y != y)))
- zone1 = e_comp_zone_xy_get(x, y);
-
- if (!zone1)
- {
- zone1 = e_comp_zone_xy_get(ec->x + (ec->w / 2), ec->y + (ec->h / 2));
- if (zone1)
- {
- E_Zone *z2 = e_comp_zone_xy_get(ec->x, ec->y);
-
- if (z2 && (z2 != zone1))
- {
- size_t psz = 0;
- E_Zone *zf = z2;
- Eina_List *l;
-
- EINA_LIST_FOREACH(e_comp->zones, l, z2)
- {
- int w, h;
-
- x = ec->x, y = ec->y, w = ec->w, h = ec->h;
- E_RECTS_CLIP_TO_RECT(x, y, w, h, z2->x, z2->y, z2->w, z2->h);
- if (w * h == z2->w * z2->h)
- {
- /* client fully covering zone */
- zf = z2;
- break;
- }
- if ((unsigned)(w * h) > psz)
- {
- psz = w * h;
- zf = z2;
- }
- }
- zone = zf;
- }
- }
- }
- if (!zone1)
- zone1 = e_comp_zone_xy_get(ec->x, ec->y);
- if (!zone1)
- zone1 = e_comp_zone_xy_get(ec->x + ec->w - 1, ec->y);
- if (!zone1)
- zone1 = e_comp_zone_xy_get(ec->x + ec->w - 1, ec->y + ec->h - 1);
- if (!zone1)
- zone1 = e_comp_zone_xy_get(ec->x, ec->y + ec->h - 1);
- if ((zone1) && (zone1 != zone))
- e_client_zone_set(ec, zone1);
- }
- }
-
- if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_NEW_CLIENT, ec))
- {
- TRACE_DS_END();
- return;
- }
-#endif
-
- /* effect changes to the window border itself */
- if ((ec->changes.shading))
- {
- /* show at start of unshade (but don't hide until end of shade) */
- ec->changes.shading = 0;
- send_event = 0;
- }
- if (ec->changes.shaded) send_event = 0;
- if ((ec->changes.shaded) && (ec->changes.pos) && (ec->changes.size))
- {
- ec->changes.shaded = 0;
- }
- else if ((ec->changes.shaded) && (ec->changes.pos))
- {
- ec->changes.size = 1;
- ec->changes.shaded = 0;
- }
- else if ((ec->changes.shaded) && (ec->changes.size))
- {
- ec->changes.shaded = 0;
- }
- else if (ec->changes.shaded)
- {
- ec->changes.shaded = 0;
- }
if (ec->changes.size)
{
ec->changes.size = 0;
- if ((!ec->shaded) && (!ec->shading))
- evas_object_resize(ec->frame, ec->w, ec->h);
+ evas_object_resize(ec->frame, ec->w, ec->h);
prop |= E_CLIENT_PROPERTY_SIZE;
}
evas_object_show(ec->frame);
if (evas_object_visible_get(ec->frame))
{
-#ifdef REFACTOR_FOCUS_POLICY
- // It is useless, Nothing to do.
-#else
- if (ec->cur_mouse_action)
- {
- ec->moveinfo.down.x = ec->x;
- ec->moveinfo.down.y = ec->y;
- ec->moveinfo.down.w = ec->w;
- ec->moveinfo.down.h = ec->h;
- ec->mouse.current.mx = x;
- ec->mouse.current.my = y;
- ec->moveinfo.down.button = 0;
- ec->moveinfo.down.mx = x;
- ec->moveinfo.down.my = y;
-
- e_object_ref(E_OBJECT(ec->cur_mouse_action));
- ec->cur_mouse_action->func.go(E_OBJECT(ec), NULL);
- if (e_config->border_raise_on_mouse_action)
- e_client_raise(ec);
- if (e_config->focus_policy_ext != E_FOCUS_EXT_TOP_STACK)
- {
- ELOGF("FOCUS", "focus set | client eval", ec);
- e_client_frame_focus_set(ec, EINA_TRUE);
- }
- }
-#endif
ec->changes.visible = 0;
_e_client_event_show(ec);
}
ec->new_client = 0;
ec->changed = ec->changes.pos || ec->changes.size ||
ec->changes.stack || ec->changes.prop || ec->changes.border ||
- ec->changes.reset_gravity || ec->changes.shading || ec->changes.shaded ||
+ ec->changes.reset_gravity ||
ec->changes.shape || ec->changes.shape_input || ec->changes.icon ||
ec->changes.internal_state ||
- ec->changes.need_maximize || ec->changes.need_unmaximize;
+ ec->changes.need_maximize || ec->changes.need_unmaximize ||
+ e_client_focus_check_get(ec);
ec->changes.stack = 0;
-#ifdef REFACTOR_FOCUS_POLICY
- // This code executes at E_CLIENT_HOOK_EVAL_END callback at e_focus_policy_topmost.c and e_focus_policy_history.c
-#else
- zone = e_comp_zone_find_by_ec(ec);
- if ((!ec->input_only) && (!ec->iconic) &&
- ((!zone) || e_desk_has_ec(e_desk_current_get(zone), ec)) &&
- ((ec->take_focus) || (ec->want_focus)))
- {
- ec->take_focus = 0;
- if (ec->want_focus)
- {
- ec->want_focus = 0;
-#if 0 // focus should be set to the top window
- e_client_focus_set_with_pointer(ec);
-#endif
- }
- else
- {
- /* focus window by default when it is the only one on desk */
- E_Client *ec2 = NULL;
- E_Desk *desk;
- Eina_List *l;
- desk = e_zone_desk_find_by_ec(zone, ec);
- EINA_LIST_FOREACH(focus_stack, l, ec2)
- {
- if (ec == ec2) continue;
- if ((!ec2->iconic) && (ec2->visible) &&
- ((e_desk_has_ec(desk, ec2)) || ec2->sticky))
- break;
- }
-
- if (!ec2)
- {
- e_client_focus_set_with_pointer(ec);
- }
- }
- }
- else
- ec->take_focus = ec->want_focus = 0;
-#endif
-
if (ec->changes.need_maximize)
{
E_Maximize max = ec->maximized;
_e_client_aux_hint_eval(ec);
e_client_transform_core_update(ec);
+
+ wl_signal_emit(&PRI(ec)->events.eval_end, NULL);
_e_client_hook_call(E_CLIENT_HOOK_EVAL_END, ec);
TRACE_DS_END();
}
-#ifdef REFACTOR_ZONE_DESK
EINTERN void
e_client_frame_update(E_Client *ec)
-#else
-static void
-_e_client_frame_update(E_Client *ec)
-#endif
{
const char *bordername;
-#ifdef REFACTOR_ZONE_DESK
EINA_SAFETY_ON_NULL_RETURN(ec);
if (e_object_is_del(E_OBJECT(ec))) return;
-#endif
ec->border.changed = 0;
if (!e_comp_object_frame_allowed(ec->frame)) return;
bordername = "borderless";
else if (ec->bordername)
bordername = ec->bordername;
- else if (ec->mwm.borderless)
- bordername = "borderless";
else if (((ec->icccm.transient_for != 0) || (ec->dialog)) &&
(ec->icccm.min_w == ec->icccm.max_w) &&
(ec->icccm.min_h == ec->icccm.max_h))
bordername = "noresize";
else if (ec->shaped)
bordername = "shaped";
- else if (ec->urgent)
- bordername = "urgent";
- else if (ec->netwm.state.modal)
- bordername = "modal";
else if ((ec->netwm.state.skip_taskbar) ||
(ec->netwm.state.skip_pager))
bordername = "skipped";
else
bordername = e_config->theme_default_border_style;
if (!bordername) bordername = "default";
-
- e_client_border_set(ec, bordername);
}
static Eina_Bool
return EINA_FALSE;
}
-static int
-_e_client_type_get(E_Client *ec)
+EINTERN int
+e_client_type_update(E_Client *ec)
{
E_Config_Client_Type *m;
Eina_List *l;
}
}
- ec->client_type = type;
+ if (ec->client_type != type)
+ {
+ ec->client_type = type;
+ _e_client_event_property(ec, E_CLIENT_PROPERTY_CLIENT_TYPE);
+ }
return ec->client_type;
}
#ifdef EC_IS_NOT_VISIBLE
# undef EC_IS_NOT_VISIBLE
#endif
-#define EC_IS_NOT_VISIBLE if (ec->visibility.obscured != E_VISIBILITY_UNOBSCURED)
+#define EC_IS_NOT_VISIBLE if (e_client_visibility_get(ec) != E_VISIBILITY_UNOBSCURED)
EINTERN Eina_Bool
e_client_visibility_touched_check(E_Client *ec)
if (ec->visibility.changed)
_e_client_event_simple(ec, E_EVENT_CLIENT_VISIBILITY_CHANGE);
+ wl_signal_emit(&PRI(ec)->events.eval_visibility, NULL);
_e_client_hook_call(E_CLIENT_HOOK_EVAL_VISIBILITY, ec);
}
_e_client_hook_call(E_CLIENT_HOOK_EVAL_VISIBILITY_END, NULL);
}
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-static void
-_e_client_merge_focus_stack_with_defer_focus(void)
+EINTERN E_Visibility
+e_client_visibility_get(E_Client *ec)
{
- Eina_List *l = NULL;
- E_Client *ec = NULL, *defer_ec = NULL;
- Eina_Bool find_rel = EINA_FALSE;
- Eina_Bool inserted = EINA_FALSE;
-
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK) return;
-
- if (!focus_stack)
- {
- focus_stack = eina_list_merge(focus_stack, defer_focus_stack);
- goto end;
- }
-
- E_CLIENT_FOREACH(defer_ec)
- {
- if (!eina_list_data_find(defer_focus_stack, defer_ec)) continue;
-
- find_rel = EINA_FALSE;
- inserted = EINA_FALSE;
- focus_stack = eina_list_remove(focus_stack, defer_ec);
-
- EINA_LIST_FOREACH(focus_stack, l, ec)
- {
- if (ec == NULL) continue;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, E_VISIBILITY_UNKNOWN);
- if (!find_rel)
- {
- if (ec == focused)
- find_rel = EINA_TRUE;
- continue;
- }
-
- if (ec->layer > defer_ec->layer) continue;
-
- focus_stack = eina_list_prepend_relative_list(focus_stack, defer_ec, l);
- inserted = EINA_TRUE;
- break;
- }
+ return ec->visibility.obscured;
+}
- if (!inserted)
- focus_stack = eina_list_append(focus_stack, defer_ec);
- }
+static void
+_e_input_thread_client_visibility_set(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
-end:
- defer_focus_stack = eina_list_free(defer_focus_stack);
- return;
+ INF("[input thread|%s] ec(%p), visibility(%d)\n", __func__, ec_data->ec, ec_data->visibility);
+ e_input_thread_client_visibility_set(e_input_thread_client_get(ec_data->ec), ec_data->visibility);
}
-static E_Client *
-_e_client_candidate_focus(E_Zone *zone, E_Client *reverted_focus_ec)
+EINTERN void
+e_client_visibility_set(E_Client *ec, E_Visibility visibility)
{
- E_Client *ec, *cec;
- E_Client *defered_focus_ec = NULL;
- Eina_List *child_list = NULL;
- Eina_List *l = NULL;
- Eina_Bool child_deferred;
- E_Desk *desk;
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
- E_CLIENT_REVERSE_FOREACH(ec)
- {
- if (!eina_list_data_find(defer_focus_stack, ec)) continue;
+ EINA_SAFETY_ON_NULL_RETURN(ec);
- if (e_object_is_del(E_OBJECT(ec))) continue;
- if (e_client_util_ignored_get(ec)) continue;
- if (!e_zone_has_ec(zone, ec)) continue;
- desk = e_desk_current_get(zone);
- if (!desk) continue;
- if (!e_desk_has_ec(desk, ec)) continue;
-
- if (!(ec->icccm.accepts_focus || ec->icccm.take_focus)) continue;
- if (ec->lock_focus_in || ec->lock_focus_out) continue;
- if (!evas_object_visible_get(ec->frame)) continue;
- if (ec->iconic) continue;
- if (ec->bg_state) continue;
-
- if (!(cec = e_client_check_obscured_by_children_group(ec)) ||
- e_client_check_really_iconified(cec))
- {
- if (ec->visibility.obscured != E_VISIBILITY_UNOBSCURED) continue;
- if (e_client_check_fully_contain_by_above(ec, EINA_FALSE)) continue;
- }
+ if (e_client_visibility_get(ec) == visibility) return;
- if (focused && (focused->layer > ec->layer)) continue;
- else if (!focused && reverted_focus_ec && (reverted_focus_ec->layer > ec->layer)) continue;
+ ec->visibility.obscured = visibility;
- // check transient_for child defered
- child_deferred = EINA_FALSE;
- child_list = eina_list_clone(ec->transients);
- EINA_LIST_FOREACH(child_list, l, cec)
- {
- if (e_client_transient_policy_get(cec) == E_TRANSIENT_BELOW) continue;
- if (!(cec->icccm.accepts_focus || cec->icccm.take_focus)) continue;
- if (eina_list_data_find(defer_focus_stack, cec))
- {
- child_deferred = EINA_TRUE;
- break;
- }
- }
- eina_list_free(child_list);
- if (child_deferred) continue;
+ ec_data.ec = ec;
+ ec_data.visibility = ec->visibility.obscured;
- defered_focus_ec = ec;
- break;
- }
- return defered_focus_ec;
+ INF("[%s] ec(%p), visibility(%d)\n", __func__, ec, ec->visibility.obscured);
+ e_input_thread_safe_call(_e_input_thread_client_visibility_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
}
-EINTERN void
-e_client_focus_calculate(E_Zone *zone)
+static Eina_Bool
+_e_client_transform_core_check_change(E_Client *ec)
{
- E_Client *defered_focus_ec = NULL, *reverted_focus_ec = NULL;
- E_Client *ec = NULL, *old_focused = NULL;
+ int w = 0;
+ int h = 0;
+ Eina_Bool check = EINA_FALSE;
+ if (!ec) return EINA_FALSE;
- EINA_SAFETY_ON_NULL_RETURN(zone);
- if (!e_zone_is_displaying(zone)) return;
+ if (ec->frame)
+ evas_object_geometry_get(ec->frame, 0, 0, &w, &h);
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK)
- {
- ec = _e_client_focus_topmost_focusable_get();
-
- if (ec != focused)
- {
- if (!ec) ELOGF("FOCUS", "focus unset | No focusable ec", focused);
- e_client_frame_focus_set(focused, EINA_FALSE);
-
- if (ec)
- {
- ELOGF("FOCUS", "focus set | topmost focus calculate", ec);
- e_client_frame_focus_set(ec, EINA_TRUE);
- }
- }
- return;
- }
-
- if ((!focused) ||
- (focused != eina_list_data_get(focus_stack)) ||
- (!_e_client_focus_can_take(focused)))
- {
- reverted_focus_ec = _e_client_revert_focus_get(focused);
- if (!reverted_focus_ec && focused)
- {
- e_client_focus_defer_unset(focused);
- old_focused = focused;
- }
- }
-
- defered_focus_ec = _e_client_candidate_focus(zone, reverted_focus_ec);
-
- if (defered_focus_ec)
- {
- if (defered_focus_ec != focused)
- {
- ELOGF("FOCUS", "focus set | focus calculate (defer_focus)", defered_focus_ec);
- if (focused)
- e_client_focus_defer_unset(focused);
- e_client_frame_focus_set(defered_focus_ec, EINA_TRUE);
- }
-
- e_client_focus_defer_unset(defered_focus_ec);
-
- _e_client_merge_focus_stack_with_defer_focus();
- }
- else if(reverted_focus_ec)
- {
- if (reverted_focus_ec != focused)
- {
- ELOGF("FOCUS", "focus set | focus calculate (revert_focus)", reverted_focus_ec);
- if (focused)
- e_client_focus_defer_unset(focused);
- e_client_frame_focus_set(reverted_focus_ec, EINA_TRUE);
- }
- }
- else if (old_focused)
- {
- ELOGF("FOCUS", "focus unset | focus calculate", old_focused);
- e_client_frame_focus_set(old_focused, EINA_FALSE);
- }
-
- return;
-}
-#endif
-
-static Eina_Bool
-_e_client_transform_core_check_change(E_Client *ec)
-{
- int w = 0;
- int h = 0;
- Eina_Bool check = EINA_FALSE;
- if (!ec) return EINA_FALSE;
-
- if (ec->frame)
- evas_object_geometry_get(ec->frame, 0, 0, &w, &h);
-
- // check client position or size change
- if (ec->x != ec->transform_core.backup.client_x ||
- ec->y != ec->transform_core.backup.client_y ||
- ec->w != ec->transform_core.backup.client_w ||
- ec->h != ec->transform_core.backup.client_h ||
- w != ec->transform_core.backup.frame_w ||
- h != ec->transform_core.backup.frame_h ||
- ec->argb != ec->transform_core.backup.argb)
+ // check client position or size change
+ if (ec->x != ec->transform_core.backup.client_x ||
+ ec->y != ec->transform_core.backup.client_y ||
+ ec->w != ec->transform_core.backup.client_w ||
+ ec->h != ec->transform_core.backup.client_h ||
+ w != ec->transform_core.backup.frame_w ||
+ h != ec->transform_core.backup.frame_h ||
+ ec->argb != ec->transform_core.backup.argb)
{
check = EINA_TRUE;
ec->transform_core.backup.client_x = ec->x;
E_Util_Transform *transform,
E_Util_Transform_Zoom zoom)
{
- E_Map *map = NULL;
+ E_Map *map = NULL, *current_map = NULL;
if (!obj) return;
if (vertices)
{
- map = _e_client_transform_core_map_new(obj, vertices, transform,
- ec->transform_core.direct_render);
- EINA_SAFETY_ON_NULL_RETURN(map);
+ if (!ec->transform_core.update_lock)
+ {
+ map = _e_client_transform_core_map_new(obj, vertices, transform,
+ ec->transform_core.direct_render);
+ EINA_SAFETY_ON_NULL_RETURN(map);
- e_map_util_zoom(map, zoom.zoom_x, zoom.zoom_y, zoom.cx, zoom.cy);
+ e_map_util_zoom(map, zoom.zoom_x, zoom.zoom_y, zoom.cx, zoom.cy);
- e_comp_object_map_set(obj, map);
- e_comp_object_map_enable_set(obj, EINA_TRUE);
+ e_comp_object_map_set(obj, map);
+ }
- e_map_free(map);
+ current_map = e_comp_object_map_get(obj);
+
+ if ((ec->transform_core.activate) && (current_map))
+ e_comp_object_map_enable_set(obj, EINA_TRUE);
+ else
+ e_comp_object_map_enable_set(obj, EINA_FALSE);
+
+ if (map) e_map_free(map);
+ if (current_map) e_map_free(current_map);
}
else
evas_object_map_enable_set(obj, EINA_FALSE);
E_Util_Transform_Rect_Vertex *vertices,
E_Util_Transform *transform)
{
- E_Map *map = NULL;
+ E_Map *map = NULL, *current_map = NULL;
if (!obj) return;
if (vertices)
{
- map = _e_client_transform_core_map_new(obj, vertices, transform,
- ec->transform_core.direct_render);
- EINA_SAFETY_ON_NULL_RETURN(map);
+ if (!ec->transform_core.update_lock)
+ {
+ map = _e_client_transform_core_map_new(obj, vertices, transform,
+ ec->transform_core.direct_render);
+ EINA_SAFETY_ON_NULL_RETURN(map);
- e_comp_object_map_set(obj, map);
- e_comp_object_map_enable_set(obj, EINA_TRUE);
+ e_comp_object_map_set(obj, map);
+ }
- e_map_free(map);
+ current_map = e_comp_object_map_get(obj);
+
+ if ((ec->transform_core.activate) && (current_map))
+ e_comp_object_map_enable_set(obj, EINA_TRUE);
+ else
+ e_comp_object_map_enable_set(obj, EINA_FALSE);
+
+ if (map) e_map_free(map);
+ if (current_map) e_map_free(current_map);
}
else
evas_object_map_enable_set(obj, EINA_FALSE);
cdata->mapped = set;
}
+EINTERN void
+e_client_modal_child_set(E_Client *ec, E_Client *modal)
+{
+ API_ENTRY;
+
+ E_Client *old_modal = priv->modal;
+ if (old_modal == modal) return;
+
+ ELOGF("E_CLIENT", "SET modal. new(ec:%p, win:0x%08zx), old(ec:%p, win:0x%08zx)", ec,
+ modal, e_client_util_win_get(modal), old_modal, e_client_util_win_get(old_modal));
+
+ // TODO: if ec has a modal window already, then how does we do?
+ priv->modal = modal;
+}
+
+EINTERN E_Client *
+e_client_modal_child_get(E_Client *ec)
+{
+ API_ENTRY_VAL(NULL);
+ return priv->modal;
+}
+
+EINTERN void
+e_client_modal_state_set(E_Client *ec, Eina_Bool modal)
+{
+ if (!ec) return;
+ ec->netwm.state.modal = modal;
+
+ if (ec->parent)
+ {
+ if (ec->netwm.state.modal)
+ e_client_modal_child_set(ec->parent, ec);
+ else
+ e_client_modal_child_set(ec->parent, NULL);
+ }
+}
+
+EINTERN Eina_Bool
+e_client_is_modal_state(E_Client *ec)
+{
+ if (!ec) return EINA_FALSE;
+ return ec->netwm.state.modal;
+}
////////////////////////////////////////////////
EINTERN Eina_Bool
EINA_LIST_FOREACH(e_comp->clients, l, ec)
{
- int client_type;
-
// pass 1 - eval0. fetch properties on new or on change and
// call hooks to decide what to do - maybe move/resize
if (ec->ignored || (!ec->changed)) continue;
+ wl_signal_emit(&PRI(ec)->events.eval_pre_fetch, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_FETCH, ec)) continue;
+
+
/* FETCH is hooked by the compositor to get client hints */
+ wl_signal_emit(&PRI(ec)->events.eval_fetch, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_FETCH, ec)) continue;
if (ec->new_client)
{
- client_type = ec->client_type;
- if (client_type != _e_client_type_get(ec))
- _e_client_event_property(ec, E_CLIENT_PROPERTY_CLIENT_TYPE);
+ e_client_type_update(ec);
}
/* PRE_POST_FETCH calls e_remember apply for new client */
+ wl_signal_emit(&PRI(ec)->events.eval_pre_post_fetch, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_POST_FETCH, ec)) continue;
+ wl_signal_emit(&PRI(ec)->events.eval_post_fetch, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_FETCH, ec)) continue;
+ wl_signal_emit(&PRI(ec)->events.eval_pre_frame_assign, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_FRAME_ASSIGN, ec)) continue;
+ wl_signal_emit(&PRI(ec)->events.eval_post_frame_assign, NULL);
_e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_FRAME_ASSIGN, ec);
}
// pass 2 - show and hide windows needing hide and eval (main eval)
if (ec->changes.accepts_focus)
*check_focus = EINA_TRUE;
ec->changes.accepts_focus = 0;
+
+ if (e_client_focus_check_get(ec))
+ {
+ *check_focus = EINA_TRUE;
+ e_client_focus_check_set(ec, EINA_FALSE);
+ }
}
if ((ec->changes.visible) && (ec->visible) && (!ec->changed))
TRACE_DS_END();
}
+static Eina_Bool
+_e_client_cb_hook_comp_render_update_lock_set(void *data, E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_TRUE);
+
+ ec->transform_core.update_lock = EINA_TRUE;
+
+ return EINA_TRUE;
+}
+
+static Eina_Bool
+_e_client_cb_hook_comp_render_update_lock_unset(void *data, E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_TRUE);
+
+ ec->transform_core.update_lock = EINA_FALSE;
+ ec->transform_core.changed = EINA_TRUE;
+
+ e_client_transform_core_update(ec);
+
+ return EINA_TRUE;
+}
EINTERN Eina_Bool
e_client_init(void)
clients_hash[pix_id] = eina_hash_pointer_new(NULL);
E_COMP_WL_HOOK_APPEND(hooks, E_COMP_WL_HOOK_SHELL_SURFACE_READY, _e_client_cb_hook_shell_surface_ready, NULL);
-
-#ifdef REFACTOR_FOCUS_POLICY
-#else
- g_mutex_init(&focused_ec_mutex);
-#endif
+ E_COMP_COMP_HOOK_APPEND(comp_hooks, E_COMP_OBJECT_HOOK_RENDER_UPDATE_LOCK_SET, _e_client_cb_hook_comp_render_update_lock_set, NULL);
+ E_COMP_COMP_HOOK_APPEND(comp_hooks, E_COMP_OBJECT_HOOK_RENDER_UPDATE_LOCK_UNSET, _e_client_cb_hook_comp_render_update_lock_unset, NULL);
E_EVENT_CLIENT_ADD = ecore_event_type_new();
E_EVENT_CLIENT_REMOVE = ecore_event_type_new();
for (pix_id = 0; pix_id < E_PIXMAP_TYPE_MAX; pix_id++)
E_FREE_FUNC(clients_hash[pix_id], eina_hash_free);
+ E_FREE_LIST(comp_hooks, e_comp_object_hook_del);
E_FREE_LIST(hooks, e_comp_wl_hook_del);
E_FREE_LIST(handlers, ecore_event_handler_del);
-#ifdef REFACTOR_FOCUS_POLICY
-#else
- g_mutex_clear(&focused_ec_mutex);
-#endif
}
E_API void
_e_client_event_add(ec);
}
+static E_Layer
+_e_client_convert_fullscreen_layer(int layer)
+{
+ if (layer <= E_LAYER_CLIENT_NORMAL)
+ return E_LAYER_CLIENT_NORMAL;
+ else if (layer <= E_LAYER_CLIENT_ABOVE)
+ return E_LAYER_CLIENT_ABOVE;
+ else if (layer <= E_LAYER_CLIENT_EDGE)
+ return E_LAYER_CLIENT_EDGE;
+ else
+ return E_LAYER_CLIENT_FULLSCREEN;
+}
+
+static void
+_e_input_thread_client_new(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec(%p), surface(%p)\n", __func__, ec_data->ec, ec_data->wl_surface);
+ e_input_thread_client_new(ec_data->ec, ec_data->wl_surface);
+}
+
E_API E_Client *
e_client_new(E_Pixmap *cp, int first_map, int internal)
{
ec->post_raise = EINA_TRUE;
ec->post_lower = EINA_FALSE;
ec->animatable = EINA_TRUE;
+ ec->maximize_type = e_config->maximize_policy & E_MAXIMIZE_TYPE;
+ ec->fullscreen_layer = _e_client_convert_fullscreen_layer(e_config->fullscreen_layer);
/* FIXME: if first_map is 1 then we should ignore the first hide event
* or ensure the window is already hidden and events flushed before we
{
ec->changes.pos = 1;
ec->re_manage = 1;
- // needed to be 1 for internal windw and on restart.
- // ec->ignore_first_unmap = 2;
}
- ec->offer_resistance = 1;
ec->new_client = 1;
e_comp->new_clients++;
e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
+ wl_signal_emit(&PRI(ec)->events.new_client, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_NEW_CLIENT, ec))
{
/* delete the above allocated object */
#else
ec->icccm.class = NULL;
#endif
- ec->icccm.icon_name = NULL;
- ec->icccm.machine = NULL;
ec->icccm.min_w = 1;
ec->icccm.min_h = 1;
ec->icccm.max_w = 32767;
ec->icccm.max_h = 32767;
- ec->icccm.base_w = 0;
- ec->icccm.base_h = 0;
- ec->icccm.step_w = -1;
- ec->icccm.step_h = -1;
- ec->icccm.min_aspect = 0.0;
- ec->icccm.max_aspect = 0.0;
ec->netwm.pid = 0;
ec->netwm.name = NULL;
- ec->netwm.icon_name = NULL;
- ec->netwm.desktop = 0;
- ec->netwm.state.modal = 0;
- ec->netwm.state.sticky = 0;
- ec->netwm.state.shaded = 0;
- ec->netwm.state.hidden = 0;
- ec->netwm.state.maximized_v = 0;
- ec->netwm.state.maximized_h = 0;
ec->netwm.state.skip_taskbar = 0;
ec->netwm.state.skip_pager = 0;
- ec->netwm.state.fullscreen = 0;
- ec->netwm.state.stacking = E_STACKING_NONE;
- ec->netwm.action.move = 0;
- ec->netwm.action.resize = 0;
- ec->netwm.action.minimize = 0;
- ec->netwm.action.shade = 0;
- ec->netwm.action.stick = 0;
- ec->netwm.action.maximized_h = 0;
- ec->netwm.action.maximized_v = 0;
- ec->netwm.action.fullscreen = 0;
- ec->netwm.action.change_desktop = 0;
- ec->netwm.action.close = 0;
ec->netwm.opacity = 255;
ec->visibility.obscured = E_VISIBILITY_UNKNOWN;
evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_client_cb_evas_move, ec);
evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _e_client_cb_evas_resize, ec);
evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESTACK, _e_client_cb_evas_restack, ec);
- evas_object_smart_callback_add(ec->frame, "shade_done", _e_client_cb_evas_shade_done, ec);
- if (ec->override)
- e_client_layer_set(ec, E_LAYER_CLIENT_ABOVE);
- else
- e_client_layer_set(ec, E_LAYER_CLIENT_NORMAL);
}
-#ifdef REFACTOR_ZONE_DESK
-#else
- if (ec->override)
- _e_client_zone_update(ec);
- else
- e_client_desk_set(ec, e_desk_current_get(e_zone_current_get()));
-#endif
+ wl_signal_emit(&PRI(ec)->events.new_client_post, NULL);
#ifdef _F_E_CLIENT_NEW_CLIENT_POST_HOOK_
_e_client_hook_call(E_CLIENT_HOOK_NEW_CLIENT_POST, ec);
ec->visibility.ignore_geometry = e_config->calc_vis_ignore_geometry;
+ E_Input_Thread_Request_EClient_Data ec_new_data;
+ memset(&ec_new_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ ec_new_data.ec = ec;
+ ec_new_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+ INF("[%s] ec(%p), surface(%p)\n", __func__, ec, ec_new_data.wl_surface);
+ e_input_thread_safe_call(_e_input_thread_client_new, &ec_new_data, sizeof(E_Input_Thread_Request_EClient_Data));
+
return ec;
}
return ec->internal;
}
-#ifdef REFACTOR_ZONE_DESK
-#else
-EINTERN void
-e_client_desk_set(E_Client *ec, E_Desk *desk)
-{
- E_Event_Client_Desk_Set *ev;
- E_Desk *old_desk;
- E_Zone *zone;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- E_OBJECT_CHECK(desk);
- E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
- if (e_desk_has_ec(desk, ec)) return;
-
- if (ec->fullscreen)
- {
- ec->desk->fullscreen_clients = eina_list_remove(ec->desk->fullscreen_clients, ec);
- desk->fullscreen_clients = eina_list_append(desk->fullscreen_clients, ec);
- }
- old_desk = ec->desk;
- if (old_desk)
- e_desk_client_del(old_desk, ec);
- ec->desk = desk;
- e_desk_client_add(desk, ec);
- if (!ec->new_client)
- {
- if (ec->frame)
- {
- e_comp_object_effect_unclip(ec->frame);
- e_comp_object_effect_set(ec->frame, NULL);
- }
- if (desk->visible || ec->sticky)
- {
- if ((!ec->hidden) && (!ec->iconic))
- evas_object_show(ec->frame);
- }
- else
- {
- ec->hidden = 1;
- evas_object_hide(ec->frame);
- }
- }
- e_client_comp_hidden_set(ec, (!desk->visible) && (!ec->sticky));
- e_client_zone_set(ec, desk->zone);
-
- if (old_desk)
- {
- ev = E_NEW(E_Event_Client_Desk_Set, 1);
- if (ev)
- {
- ev->ec = ec;
- UNREFD(ec, 4);
- e_object_ref(E_OBJECT(ec));
- ev->desk = old_desk;
- e_object_ref(E_OBJECT(old_desk));
- ecore_event_add(E_EVENT_CLIENT_DESK_SET, ev, (Ecore_End_Cb)_e_client_event_desk_set_free, NULL);
- }
-
- zone = e_comp_zone_find_by_ec(ec);
- if (old_desk->zone == zone)
- {
- e_client_res_change_geometry_save(ec);
- e_client_res_change_geometry_restore(ec);
- ec->pre_res_change.valid = 0;
- }
- }
-
- if (e_config->transient.desktop)
- {
- E_Client *child;
- const Eina_List *l;
-
- EINA_LIST_FOREACH(ec->transients, l, child)
- e_client_desk_set(child, ec->desk);
- }
-
- _e_client_hook_call(E_CLIENT_HOOK_DESK_SET, ec);
- evas_object_smart_callback_call(ec->frame, "desk_change", ec);
-
- if (ec->desk->desk_area.enable)
- {
- if (!ec->desk_area.desk_area)
- {
- E_Desk_Area *eda;
- eda = e_desk_desk_area_base_get(ec->desk);
- e_client_desk_area_set(ec, eda);
- }
-
- e_client_desk_area_enable_set(ec, EINA_TRUE);
- }
-}
-#endif
-
EINTERN void
e_client_desk_iconify_skip_set(E_Client *ec, Eina_Bool skip)
{
ec->mouse.current.my = y;
ec->mouse.in = 1;
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_MOUSE_IN, ec);
-#else
- if ((!ec->iconic) && (!e_client_util_ignored_get(ec)))
- e_focus_event_mouse_in(ec);
-#endif
+ wl_signal_emit(&PRI(ec)->events.mouse_in, NULL);
}
EINTERN void
ec->mouse.current.my = y;
ec->mouse.in = 0;
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_MOUSE_OUT, ec);
-#else
- if ((!ec->iconic) && (!e_client_util_ignored_get(ec)))
- e_focus_event_mouse_out(ec);
-#endif
+ wl_signal_emit(&PRI(ec)->events.mouse_out, NULL);
}
EINTERN void
EINTERN void
e_client_mouse_down(E_Client *ec, int button, Evas_Point *output, E_Binding_Event_Mouse_Button *ev)
{
-#ifdef REFACTOR_FOCUS_POLICY
-#else
- E_Client *focused;
-#endif
-
EINA_SAFETY_ON_NULL_RETURN(ec);
+
if (action_client || ec->iconic || e_client_util_ignored_get(ec)) return;
if ((button >= 1) && (button <= 3))
{
ec->mouse.current.mx = output->x;
ec->mouse.current.my = output->y;
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_MOUSE_DOWN, ec);
-#else
- focused = e_client_focused_get();
- if ((focused) && (ec != focused))
- {
- e_focus_event_mouse_down(ec);
- }
-#endif
+ wl_signal_emit(&PRI(ec)->events.mouse_down, NULL);
}
EINTERN void
memcpy(&ec->pre_res_change, &pre_res_change, sizeof(pre_res_change));
}
-#ifdef REFACTOR_ZONE_DESK
-#else
-EINTERN void
-e_client_zone_set(E_Client *ec, E_Zone *zone)
-{
- E_Event_Client_Zone_Set *ev;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- E_OBJECT_CHECK(zone);
- E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
- if (e_zone_has_ec(zone, ec)) return;
-
- ev = E_NEW(E_Event_Client_Zone_Set, 1);
- if (!ev) return;
-
- /* if the window does not lie in the new zone, move it so that it does */
- if (!E_INTERSECTS(ec->x, ec->y, ec->w, ec->h, zone->x, zone->y, zone->w, zone->h))
- {
- int x, y;
-
- x = ec->x, y = ec->y;
-
- /* keep window from hanging off bottom and left */
- if (x + ec->w > zone->x + zone->w) x += (zone->x + zone->w) - (x + ec->w);
- if (y + ec->h > zone->y + zone->h) y += (zone->y + zone->h) - (y + ec->h);
-
- /* make sure to and left are on screen (if the window is larger than the zone, it will hang off the bottom / right) */
- if (x < zone->x) x = zone->x;
- if (y < zone->y) y = zone->y;
-
- if (!E_INTERSECTS(x, y, ec->w, ec->h, zone->x, zone->y, zone->w, zone->h))
- {
- /* still not in zone at all, so just move it to closest edge */
- if (x < zone->x) x = zone->x;
- if (x >= zone->x + zone->w) x = zone->x + zone->w - ec->w;
- if (y < zone->y) y = zone->y;
- if (y >= zone->y + zone->h) y = zone->y + zone->h - ec->h;
- }
- evas_object_move(ec->frame, x, y);
- }
-
- // TODO: NEED TO DELETE LINE BELOW
- ec->zone = zone;
-
- ev->ec = ec;
- REFD(ec, 5);
- e_object_ref(E_OBJECT(ec));
- ev->zone = zone;
- e_object_ref(E_OBJECT(zone));
-
- ecore_event_add(E_EVENT_CLIENT_ZONE_SET, ev, (Ecore_End_Cb)_e_client_event_zone_set_free, NULL);
-
- // TODO: change all use of e_client_zone_set() to e_zone_client_add()
- e_zone_client_add(zone, ec);
-}
-#endif
-
EINTERN void
e_client_pos_set(E_Client *ec, int x, int y)
{
E_API E_Client *
e_client_above_get(const E_Client *ec)
{
+#ifdef REFACTOR_DESK_AREA
+ API_ENTRY_VAL(NULL);
+
+ E_Client_Data_Get_Above data;
+
+ data.above_ec = NULL;
+
+ wl_signal_emit(&priv->events.get_above, &data);
+
+ return data.above_ec;
+#else
unsigned int x;
E_Client *ec2;
if (ec->layer == E_LAYER_CLIENT_CURSOR) return NULL;
if (e_comp_canvas_client_layer_map(ec->layer) == 9999) return NULL;
+ g_rec_mutex_lock(&e_comp->ec_list_mutex);
/* go up the layers until we find one */
for (x = e_comp_canvas_layer_map(ec->layer) + 1; x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
{
continue;
}
if (!e_object_is_del(E_OBJECT(ec2)))
- return ec2;
+ {
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+ return ec2;
+ }
}
}
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+
return NULL;
+#endif
}
E_API E_Client *
e_client_below_get(const E_Client *ec)
{
+#ifdef REFACTOR_DESK_AREA
+ API_ENTRY_VAL(NULL);
+
+ E_Client_Data_Get_Below data;
+
+ data.below_ec = NULL;
+
+ wl_signal_emit(&priv->events.get_below, &data);
+
+ return data.below_ec;
+#else
unsigned int x;
E_Client *ec2;
Eina_Inlist *l;
x = e_comp_canvas_layer_map(ec_layer);
if (x > 0) x--;
+ g_rec_mutex_lock(&e_comp->ec_list_mutex);
for (; x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
{
if (!e_comp->layers[x].clients) continue;
continue;
}
if (!e_object_is_del(E_OBJECT(ec2)))
- return ec2;
+ {
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+ return ec2;
+ }
}
}
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+
return NULL;
+#endif
}
-E_API E_Client *
-e_client_bottom_get(void)
+EINTERN E_Client *
+e_client_visible_above_get(E_Client *ec)
{
- unsigned int x;
- for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
- {
- E_Client *ec2;
+#ifdef REFACTOR_DESK_AREA
+ API_ENTRY_VAL(NULL);
- if (!e_comp->layers[x].clients) continue;
- EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
- if (!e_object_is_del(E_OBJECT(ec2)))
- return ec2;
- }
- return NULL;
-}
+ E_Client_Data_Get_Visible_Above data;
-E_API E_Client *
-e_client_top_get(void)
-{
+ data.above_ec = NULL;
+
+ wl_signal_emit(&priv->events.get_visible_above, &data);
+
+ return data.above_ec;
+#else
unsigned int x;
+ E_Client *ec2;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
+ if (EINA_INLIST_GET(ec)->next) //check current layer
+ {
+ EINA_INLIST_FOREACH(EINA_INLIST_GET(ec)->next, ec2)
+ {
+ if (ec == ec2) continue;
+ if ((!e_object_is_del(E_OBJECT(ec2))) &&
+ (!e_client_util_ignored_get(ec2)) &&
+ (ec2->visible) &&
+ (ec2->frame))
+ return ec2;
+ }
+ }
+
+ if (ec->layer == E_LAYER_CLIENT_CURSOR) return NULL;
+ if (e_comp_canvas_client_layer_map(ec->layer) == 9999) return NULL;
+
+ /* go up the layers until we find one */
+ for (x = e_comp_canvas_layer_map(ec->layer) + 1; x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
+ {
+ if (!e_comp->layers[x].clients) continue;
+ EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
+ {
+ if (ec == ec2) continue;
+ if ((!e_object_is_del(E_OBJECT(ec2))) &&
+ (!e_client_util_ignored_get(ec2)) &&
+ (ec2->visible) &&
+ (ec2->frame))
+ return ec2;
+ }
+ }
+
+ return NULL;
+#endif
+}
+
+EINTERN E_Client *
+e_client_visible_below_get(E_Client *ec)
+{
+#ifdef REFACTOR_DESK_AREA
+ API_ENTRY_VAL(NULL);
+
+ E_Client_Data_Get_Visible_Below data;
+
+ data.below_ec = NULL;
+
+ wl_signal_emit(&priv->events.get_visible_below, &data);
+
+ return data.below_ec;
+#else
+ unsigned int x;
+ E_Client *ec2;
+ Eina_Inlist *l;
+ E_Layer ec_layer, ec_layer_cw;
+ int cw_layer;
+
+ E_OBJECT_CHECK_RETURN(ec, NULL);
+ E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
+ if (EINA_INLIST_GET(ec)->prev) //check current layer
+ {
+ for (l = EINA_INLIST_GET(ec)->prev; l; l = l->prev)
+ {
+ ec2 = EINA_INLIST_CONTAINER_GET(l, E_Client);
+ if (ec == ec2) continue;
+ if ((!e_object_is_del(E_OBJECT(ec2))) &&
+ (!e_client_util_ignored_get(ec2)) &&
+ (ec2->visible) &&
+ (ec2->frame))
+ return ec2;
+ }
+ }
+
+ // check layer validation
+ ec_layer = ec->layer;
+ if (ec->layer_block || ec->layer_pending)
+ {
+ cw_layer = e_comp_object_layer_get(ec->frame);
+ if (cw_layer >= 0)
+ {
+ ec_layer_cw = e_comp_canvas_layer_map_to(cw_layer);
+ if (ec_layer != ec_layer_cw)
+ {
+ ELOGF("COMP", "LAYER is not same. USE obj layer! (ec->layer:%d, obj:%d). block:%d, pending:%d)", ec, ec_layer, ec_layer_cw, ec->layer_block, ec->layer_pending);
+ ec_layer = ec_layer_cw;
+ }
+ }
+ }
+
+ /* go down the layers until we find one */
+ if (e_comp_canvas_layer_map(ec->layer) > e_comp_canvas_layer_map(E_LAYER_MAX)) return NULL;
+ x = e_comp_canvas_layer_map(ec->layer);
+ if (x > 0) x--;
+
+ for (; x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
+ {
+ if (!e_comp->layers[x].clients) continue;
+ EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
+ {
+ if (ec == ec2) continue;
+ if ((!e_object_is_del(E_OBJECT(ec2))) &&
+ (!e_client_util_ignored_get(ec2)) &&
+ (ec2->visible) &&
+ (ec2->frame))
+ return ec2;
+ }
+ }
+
+ return NULL;
+#endif
+}
+
+E_API E_Client *
+e_client_bottom_get(void)
+{
+#ifdef REFACTOR_DESK_AREA
+ E_Zone *zone;
+ E_Desk *desk;
+
+ // get the bottom ec from current desk at current zone
+ zone = e_zone_current_get();
+ desk = e_desk_current_get(zone);
+
+ return e_desk_bottom_ec_get(desk);
+#else
+ unsigned int x;
+ g_rec_mutex_lock(&e_comp->ec_list_mutex);
+ for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
+ {
+ E_Client *ec2;
+
+ if (!e_comp->layers[x].clients) continue;
+ EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
+ if (!e_object_is_del(E_OBJECT(ec2)))
+ {
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+ return ec2;
+ }
+ }
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+
+ return NULL;
+#endif
+}
+
+E_API E_Client *
+e_client_top_get(void)
+{
+#ifdef REFACTOR_DESK_AREA
+ E_Zone *zone;
+ E_Desk *desk;
+
+ // get the top ec from current desk at current zone
+ zone = e_zone_current_get();
+ desk = e_desk_current_get(zone);
+
+ return e_desk_top_ec_get(desk);
+#else
+ unsigned int x;
+ g_rec_mutex_lock(&e_comp->ec_list_mutex);
for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
{
E_Client *ec2;
if (!e_comp->layers[x].clients) continue;
EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
if (!e_object_is_del(E_OBJECT(ec2)))
- return ec2;
+ {
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+ return ec2;
+ }
}
+ g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+
return NULL;
+#endif
}
EINTERN unsigned int
_e_client_intercept_hooks_delete++;
}
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-EINTERN void
-e_client_focus_stack_lower(E_Client *ec)
-{
- Eina_List *l = NULL;
- E_Client *ec2 = NULL;
-
- EINA_SAFETY_ON_NULL_RETURN(ec);
-
- focus_stack = eina_list_remove(focus_stack, ec);
-
- EINA_LIST_REVERSE_FOREACH(focus_stack, l, ec2)
- {
- if (ec2 == NULL) continue;
- if (ec2->layer < ec->layer) continue;
-
- focus_stack = eina_list_append_relative_list(focus_stack, ec, l);
- return;
- }
-
- focus_stack = eina_list_prepend(focus_stack, ec);
- return;
-}
-#endif
-
E_API void
e_client_focus_latest_set(E_Client *ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_FOCUS_LATEST_SET, ec);
-#else
- focus_stack = eina_list_remove(focus_stack, ec);
- focus_stack = eina_list_prepend(focus_stack, ec);
-#endif
-}
-
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-EINTERN void
-e_client_focus_stack_append_current_focused(E_Client *ec)
-{
- Eina_List *l = NULL;
- E_Client *temp_ec = NULL;
-
- if (!ec) CRI("ACK");
-
- focus_stack = eina_list_remove(focus_stack, ec);
-
- EINA_LIST_FOREACH(focus_stack, l, temp_ec)
- {
- if (temp_ec != focused) continue;
-
- focus_stack = eina_list_append_relative_list(focus_stack, ec, l);
- return;
- }
-
- focus_stack = eina_list_prepend(focus_stack, ec);
- return;
+ wl_signal_emit(&PRI(ec)->events.focus_latest_set, NULL);
}
-#endif
E_API void
e_client_focus_defer_set(E_Client *ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_FOCUS_DEFER_SET, ec);
-#else
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK) return;
-
- ELOGF("FOCUS", "focus defer set", ec);
-
- defer_focus_stack = eina_list_remove(defer_focus_stack, ec);
- defer_focus_stack = eina_list_prepend(defer_focus_stack, ec);
-#endif
-}
-
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-EINTERN void
-e_client_focus_defer_unset(E_Client *ec)
-{
- EINA_SAFETY_ON_NULL_RETURN(ec);
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK) return;
-
- ELOGF("FOCUS", "focus defer unset", ec);
-
- defer_focus_stack = eina_list_remove(defer_focus_stack, ec);
-}
-
-EINTERN void
-e_client_focus_defer_clear(void)
-{
- if (!defer_focus_stack) return;
-
- ELOGF("FOCUS", "focus defer clear", NULL);
-
- defer_focus_stack = eina_list_free(defer_focus_stack);
-}
-
-EINTERN void
-e_client_refocus(void)
-{
- E_Client *ec;
- const Eina_List *l;
- E_Desk *desk;
-
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK) return;
-
- EINA_LIST_FOREACH(e_client_focus_stack_get(), l, ec)
- {
- desk = e_comp_desk_find_by_ec(ec);
- if (!desk) continue;
- if (desk->visible && (!ec->iconic))
- {
- g_mutex_lock(&e_comp->input_key_grabs_mutex);
- if (e_comp->input_key_grabs || e_comp->input_mouse_grabs)
- {
- g_mutex_unlock(&e_comp->input_key_grabs_mutex);
- break;
- }
- g_mutex_unlock(&e_comp->input_key_grabs_mutex);
- ELOGF("FOCUS", "focus set | refocus", ec);
- e_client_frame_focus_set(ec, EINA_TRUE);
- break;
- }
- }
-}
-
-
-/*
- * Sets the focus to the given client if necessary
- * There are 3 cases of different focus_policy-configurations:
- *
- * - E_FOCUS_CLICK: just set the focus, the most simple one
- *
- * - E_FOCUS_MOUSE: focus is where the mouse is, so try to
- * warp the pointer to the window. If this fails (because
- * the pointer is already in the window), just set the focus.
- *
- * - E_FOCUS_SLOPPY: focus is where the mouse is or on the
- * last window which was focused, if the mouse is on the
- * desktop. So, we need to look if there is another window
- * under the pointer and warp to pointer to the right
- * one if so (also, we set the focus afterwards). In case
- * there is no window under pointer, the pointer is on the
- * desktop and so we just set the focus.
- *
- *
- * This function is to be called when setting the focus was not
- * explicitly triggered by the user (by moving the mouse or
- * clicking for example), but implicitly (by closing a window,
- * the last focused window should get focus).
- *
- */
-EINTERN void
-e_client_focus_set_with_pointer(E_Client *ec)
-{
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- /* note: this is here as it seems there are enough apps that do not even
- * expect us to emulate a look of focus but not actually set x input
- * focus as we do - so simply abort any focuse set on such windows */
- /* be strict about accepting focus hint */
- if (e_config->focus_policy_ext == E_FOCUS_EXT_TOP_STACK) return;
-
- if ((!ec->icccm.accepts_focus) &&
- (!ec->icccm.take_focus)) return;
- if (ec->lock_focus_out) return;
- if (ec == focused) return;
-
- TRACE_DS_BEGIN(CLIENT:FOCUS SET WITH POINTER);
- ELOGF("FOCUS", "focus set | focus with pointer", ec);
- e_client_frame_focus_set(ec, EINA_TRUE);
-
- if (e_config->focus_policy == E_FOCUS_CLICK)
- {
- TRACE_DS_END();
- return;
- }
- if (!ec->visible)
- {
- TRACE_DS_END();
- return;
- }
- TRACE_DS_END();
+ wl_signal_emit(&PRI(ec)->events.focus_defer_set, NULL);
}
-#endif
EINTERN void
e_client_focused_set(E_Client *ec)
{
-#ifdef REFACTOR_FOCUS_POLICY
E_Client *focused_ec;
E_Zone *zone;
{
if (!e_object_is_del(E_OBJECT(focused_ec)))
{
+ // FIXME: Remove focus_unset event of client.
+ // Instead, make zone focus_unset event and use it.
+ wl_signal_emit(&PRI(focused_ec)->events.focus_unset, NULL);
_e_client_hook_call(E_CLIENT_HOOK_FOCUS_UNSET, focused_ec);
if (e_object_ref_get(E_OBJECT(focused_ec)) > 0)
{
_e_client_event_simple(focused_ec, E_EVENT_CLIENT_FOCUS_OUT);
- e_client_urgent_set(focused_ec, focused_ec->icccm.urgent);
}
}
}
return;
}
+ // FIXME: Remove focus_set event of client.
+ // Instead, make zone focus_set event and use it.
// set the new current focused_ec
+ wl_signal_emit(&PRI(ec)->events.focus_set, NULL);
_e_client_hook_call(E_CLIENT_HOOK_FOCUS_SET, ec);
// send the client_focuse_in event
_e_client_event_simple(ec, E_EVENT_CLIENT_FOCUS_IN);
-#ifdef REFACTOR_ZONE_DESK
-#else
- // TODO: This is not for focus, but for Window Placement policy.
- // Move this code to the better place.
- if (ec->sticky && ec->desk && (!ec->desk->visible))
- e_client_desk_set(ec, e_desk_current_get(zone));
-#endif
-
TRACE_DS_END();
-#else
- E_Client *ec2, *ec_unfocus = focused;
- Eina_List *l, *ll;
- E_Zone *zone;
+}
- if (ec == focused) return;
+EINTERN void
+e_client_activate(E_Client *ec)
+{
+ E_OBJECT_CHECK(ec);
+ E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- TRACE_DS_BEGIN(CLIENT:FOCUSED SET);
+ TRACE_DS_BEGIN(CLIENT:ACTIVATE);
- ELOGF("FOCUS", "CLIENT FOCUS_SET", ec);
+ ELOGF("COMP", "Set launching flag..", ec);
+ ec->launching = EINA_TRUE;
- g_mutex_lock(&focused_ec_mutex);
- focused = ec;
- g_mutex_unlock(&focused_ec_mutex);
+ ec->exp_iconify.not_raise = 0;
- zone = e_comp_zone_find_by_ec(ec);
- if (zone)
+ if (ec->iconic)
{
- ec->focused = 1;
- e_client_urgent_set(ec, 0);
- int x, total = zone->desk_x_count * zone->desk_y_count;
-
- for (x = 0; x < total; x++)
- {
- E_Desk *desk = zone->desks[x];
- /* if there's any fullscreen non-parents on this desk, unfullscreen them */
- EINA_LIST_FOREACH_SAFE(desk->fullscreen_clients, l, ll, ec2)
- {
- if (ec2 == ec) continue;
- if (e_object_is_del(E_OBJECT(ec2))) continue;
- /* but only if it's the same desk or one of the clients is sticky */
- if ((e_desk_has_ec(desk, ec)) || (ec->sticky || ec2->sticky))
- {
- if (!eina_list_data_find(ec->transients, ec2))
- e_client_unfullscreen(ec2);
- }
- }
- }
+ if (!ec->lock_user_iconify)
+ e_client_uniconify(ec);
}
+ ELOGF("COMP", "Un-Set ICONIFY BY CLIENT", ec);
+ ec->exp_iconify.by_client = 0;
+ e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
- while ((ec_unfocus) && (ec_unfocus->zone))
- {
- ec_unfocus->want_focus = ec_unfocus->focused = 0;
- if (ec_unfocus->mouse.in && ec && (!e_client_util_is_popup(ec)) &&
- (e_config->focus_policy != E_FOCUS_CLICK))
- e_client_mouse_out(ec_unfocus, ec_unfocus->x - 1, ec_unfocus->y - 1);
+ wl_signal_emit(&PRI(ec)->events.activate_done, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_ACTIVATE_DONE, ec);
- /* if there unfocus client is fullscreen and visible */
- if ((ec_unfocus->fullscreen) && (!ec_unfocus->iconic) && (!ec_unfocus->hidden) &&
- (ec_unfocus->zone == e_zone_current_get()) &&
- ((ec_unfocus->desk == e_desk_current_get(ec_unfocus->zone)) || (ec_unfocus->sticky)))
- {
- Eina_Bool have_vis_child = EINA_FALSE;
-
- /* if any of its children are visible */
- EINA_LIST_FOREACH(ec_unfocus->transients, l, ec2)
- {
- if ((ec2->zone == ec_unfocus->zone) &&
- ((ec2->desk == ec_unfocus->desk) ||
- (ec2->sticky) || (ec_unfocus->sticky)))
- {
- have_vis_child = EINA_TRUE;
- break;
- }
- }
- /* if no children are visible, unfullscreen */
- if ((!e_object_is_del(E_OBJECT(ec_unfocus))) && (!have_vis_child))
- e_client_unfullscreen(ec_unfocus);
- }
-
- if (!e_object_is_del(E_OBJECT(ec_unfocus)))
- _e_client_hook_call(E_CLIENT_HOOK_FOCUS_UNSET, ec_unfocus);
- /* only send event here if we're not being deleted */
- if ((!e_object_is_del(E_OBJECT(ec_unfocus))) &&
- (e_object_ref_get(E_OBJECT(ec_unfocus)) > 0))
- {
- _e_client_event_simple(ec_unfocus, E_EVENT_CLIENT_FOCUS_OUT);
- e_client_urgent_set(ec_unfocus, ec_unfocus->icccm.urgent);
- }
-
- e_client_focus_defer_unset(ec_unfocus);
- break;
- }
- if (!ec)
- {
- TRACE_DS_END();
- return;
- }
-
- _e_client_hook_call(E_CLIENT_HOOK_FOCUS_SET, ec);
-
- e_client_focus_latest_set(ec);
-
- _e_client_event_simple(ec, E_EVENT_CLIENT_FOCUS_IN);
-
-#ifdef REFACTOR_ZONE_DESK
-#else
- if (ec->sticky && ec->desk && (!ec->desk->visible))
- e_client_desk_set(ec, e_desk_current_get(zone));
-#endif
-
- TRACE_DS_END();
-#endif
-}
-
-EINTERN void
-e_client_activate(E_Client *ec)
-{
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
-
- TRACE_DS_BEGIN(CLIENT:ACTIVATE);
-
- ELOGF("COMP", "Set launching flag..", ec);
- ec->launching = EINA_TRUE;
-
- ec->exp_iconify.not_raise = 0;
-
- if (ec->iconic)
- {
- if (!ec->lock_user_iconify)
- e_client_uniconify(ec);
- }
- ELOGF("COMP", "Un-Set ICONIFY BY CLIENT", ec);
- ec->exp_iconify.by_client = 0;
- e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
-
-#ifdef REFACTOR_ZONE_DESK
-#else
- if ((!ec->iconic) && (!ec->sticky))
- {
- e_desk_show(ec->desk);
- }
- if (!ec->lock_user_stacking)
- e_client_raise(ec);
- if (ec->shaded || ec->shading)
- e_client_unshade(ec, ec->shade_dir);
-#endif
-
-#ifdef REFACTOR_FOCUS_POLICY
- // This code will be executed at E_CLIENT_HOOK_ACTIVATE_DONE callback at e_focus_policy_history.c
-#else
- if (!ec->lock_focus_out)
- {
- E_Client *focus_ec = NULL;
- E_Client *obscured_above = NULL;
-
- if (ec->transients)
- focus_ec = e_client_transient_child_top_get(ec, EINA_TRUE);
-
- if (!focus_ec)
- focus_ec = ec;
- else
- {
- e_client_focus_latest_set(ec);
- e_client_focus_latest_set(focus_ec);
- e_client_focus_defer_unset(ec);
- }
-
- obscured_above = e_client_check_fully_contain_by_above(focus_ec, EINA_FALSE);
- if (!obscured_above)
- {
- if (!e_policy_visibility_client_is_uniconic(ec))
- {
- e_client_focus_defer_set(focus_ec);
- e_client_focus_latest_set(focus_ec);
- }
- else
- {
- if (e_config->focus_policy_ext != E_FOCUS_EXT_TOP_STACK)
- {
- ELOGF("FOCUS", "focus set | client activate", focus_ec);
- e_client_frame_focus_set(focus_ec, EINA_TRUE);
- }
- }
- }
- else
- {
- e_client_focus_defer_set(focus_ec);
- e_client_focus_latest_set(focus_ec);
- }
- }
-#endif
-
-#ifdef REFACTOR_ZONE_DESK
-#else
- if (!e_client_desk_iconify_skip_get(ec))
- {
- e_desk_visible_client_iconified_list_remove_all(ec->desk);
- }
-#endif
-
- _e_client_hook_call(E_CLIENT_HOOK_ACTIVATE_DONE, ec);
-
- TRACE_DS_END();
-}
+ TRACE_DS_END();
+}
E_API E_Client *
e_client_focused_get(void)
{
-#ifdef REFACTOR_FOCUS_POLICY
return e_comp_focused_ec_get();
-#else
- E_Client *focused_ec = NULL;
-
- g_mutex_lock(&focused_ec_mutex);
- focused_ec = focused;
- g_mutex_unlock(&focused_ec_mutex);
-
- return focused_ec;
-#endif
-}
-
-#ifdef REFACTOR_FOCUS_POLICY
-#else
-EINTERN Eina_List *
-e_client_focus_stack_get(void)
-{
- return focus_stack;
-}
-
-EINTERN Eina_List *
-e_client_defer_focus_stack_get(void)
-{
- return defer_focus_stack;
-}
-
-YOLO EINTERN void
-e_client_focus_stack_set(Eina_List *l)
-{
- focus_stack = l;
-}
-
-EINTERN void
-e_client_focus_stack_clear(void)
-{
- if (!focus_stack) return;
-
- focus_stack = eina_list_free(focus_stack);
}
-#endif
EINTERN Eina_List *
e_client_lost_windows_get(E_Zone *zone)
///////////////////////////////////////
EINTERN void
-e_client_shade(E_Client *ec, E_Direction dir)
-{
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- if ((ec->shaded) || (ec->shading) || (ec->fullscreen) ||
- ((ec->maximized) && (!e_config->allow_manip))) return;
- if (!e_util_strcmp("borderless", ec->bordername)) return;
- if (!e_comp_object_frame_allowed(ec->frame)) return;
-
- ec->take_focus = 0;
- ec->shading = 1;
- ec->shade_dir = dir;
-
- evas_object_smart_callback_call(ec->frame, "shaded", (uintptr_t*)dir);
-}
-
-EINTERN void
-e_client_unshade(E_Client *ec, E_Direction dir)
-{
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- if ((!ec->shaded) || (ec->shading))
- return;
-
- ec->shading = 1;
- ec->shade_dir = 0;
-
- evas_object_smart_callback_call(ec->frame, "unshaded", (uintptr_t*)dir);
-}
-
-///////////////////////////////////////
-
-EINTERN void
e_client_maximized_geometry_set(E_Client *ec, int x, int y, int w, int h)
{
if (!ec) return;
E_API void
e_client_maximize(E_Client *ec, E_Maximize max)
{
-#ifdef REFACTOR_ZONE_DESK
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
-
- if (!(max & E_MAXIMIZE_DIRECTION)) max |= E_MAXIMIZE_BOTH;
-
- if ((ec->shaded) || (ec->shading)) return;
-
- if ((ec->maximized & E_MAXIMIZE_DIRECTION) == (max & E_MAXIMIZE_DIRECTION))
- {
- if ((ec->maximized & E_MAXIMIZE_TYPE) == (max & E_MAXIMIZE_TYPE))
- return;
- }
-
- if (ec->new_client)
- {
- ec->changes.need_maximize = 1;
- ec->maximized &= ~E_MAXIMIZE_TYPE;
- ec->maximized |= max;
- EC_CHANGED(ec);
- return;
- }
-
- // store the E_Maximize value requested
- ec->requested_max = max;
-
- // call the maximize hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_MAXIMIZE, ec);
-
- // clear the E_Maximize value requested
- ec->requested_max = E_MAXIMIZE_NONE;
-
- // store the E_Maximize value
- ec->maximized = max;
- ec->changes.need_unmaximize = 0;
-
- evas_object_smart_callback_call(ec->frame, "maximize_done", NULL);
-#else
- int desk_x, desk_y;
- E_Zone *zone;
-
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return;
if (!(max & E_MAXIMIZE_DIRECTION)) max |= E_MAXIMIZE_BOTH;
- if ((ec->shaded) || (ec->shading)) return;
-
if ((ec->maximized & E_MAXIMIZE_DIRECTION) == (max & E_MAXIMIZE_DIRECTION))
{
if ((ec->maximized & E_MAXIMIZE_TYPE) == (max & E_MAXIMIZE_TYPE))
return;
}
- if (ec->desk_area.enable && ec->desk_area.desk_area)
+ if (!ec->fullscreen)
{
- desk_x = ec->desk_area.desk_area->x;
- desk_y = ec->desk_area.desk_area->y;
- }
- else
- {
- desk_x = ec->desk->geom.x;
- desk_y = ec->desk->geom.y;
- }
+ // call the maximize hook of a client
+ wl_signal_emit(&PRI(ec)->events.maximize, &max);
- evas_object_smart_callback_call(ec->frame, "maximize_pre", NULL);
-
- if (ec->fullscreen)
- e_client_unfullscreen(ec);
- ec->pre_res_change.valid = 0;
- if (!(ec->maximized & E_MAXIMIZE_HORIZONTAL))
- {
- /* Horizontal hasn't been set */
- ec->saved.x = ec->client.x - desk_x;
- ec->saved.w = ec->client.w;
+ // store the E_Maximize value
+ ec->maximized = max;
+ ec->changes.need_unmaximize = 0;
}
- if (!(ec->maximized & E_MAXIMIZE_VERTICAL))
+ else
{
- /* Vertical hasn't been set */
- ec->saved.y = ec->client.y - desk_y;
- ec->saved.h = ec->client.h;
+ // store the E_Maximize value
+ ec->maximized = max;
+ ec->changes.need_unmaximize = 0;
}
-
- ec->saved.zone = zone->num;
-
- _e_client_maximize(ec, max);
-
- ec->maximized = max;
- ec->changes.need_unmaximize = 0;
-
- evas_object_smart_callback_call(ec->frame, "maximize_done", NULL);
-#endif
}
E_API void
e_client_unmaximize(E_Client *ec, E_Maximize max)
{
-#ifdef REFACTOR_ZONE_DESK
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
return;
}
- if ((ec->shaded) || (ec->shading)) return;
-
/* Remove directions not used */
max &= (ec->maximized & E_MAXIMIZE_DIRECTION);
/* Can only remove existing maximization directions */
if (!max) return;
- evas_object_smart_callback_call(ec->frame, "unmaximize_pre", NULL);
-
- // store the E_Maximize value requested
- ec->requested_max = max;
-
- // call the unmaximize hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_UNMAXIMIZE, ec);
-
- // clear the E_Maximize value requested
- ec->requested_max = E_MAXIMIZE_NONE;
+ if (!ec->fullscreen)
+ {
+ // call the unmaximize hook of a client
+ wl_signal_emit(&PRI(ec)->events.unmaximize, &max);
+ }
- evas_object_smart_callback_call(ec->frame, "unmaximize_done", NULL);
+ ec->maximized = E_MAXIMIZE_NONE;
ec->changes.need_unmaximize = 0;
-#else
- E_Zone *zone;
+}
+EINTERN void
+e_client_fullscreen(E_Client *ec, E_Fullscreen policy)
+{
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return;
- if (!(max & E_MAXIMIZE_DIRECTION))
- {
- CRI("BUG: Unmaximize call without direction!");
- return;
- }
+ if (ec->fullscreen) return;
+
+ // call the fullscreen_pre hook of a client
+ wl_signal_emit(&PRI(ec)->events.fullscreen_pre, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_FULLSCREEN_PRE, ec);
+
+ if (ec->skip_fullscreen) return;
if (ec->new_client)
{
- ec->changes.need_unmaximize = 1;
- EC_CHANGED(ec);
+ ec->need_fullscreen = 1;
return;
}
- if ((ec->shaded) || (ec->shading)) return;
-
- /* Remove directions not used */
- max &= (ec->maximized & E_MAXIMIZE_DIRECTION);
- /* Can only remove existing maximization directions */
- if (!max) return;
-
- evas_object_smart_callback_call(ec->frame, "unmaximize_pre", NULL);
-
- if (ec->maximized & E_MAXIMIZE_TYPE)
- {
- ec->pre_res_change.valid = 0;
- ec->changes.need_maximize = 0;
+ ec->saved.layer = ec->layer;
+ e_client_layer_set(ec, ec->fullscreen_layer);
- 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 + zone->x,
- ec->saved.y + zone->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;
+ ec->fullscreen = 1;
- w = ec->client.w;
- h = ec->client.h;
- x = ec->client.x;
- y = ec->client.y;
+ // call the fullscreen hook of a client
+ wl_signal_emit(&PRI(ec)->events.fullscreen, &policy);
- if (max & E_MAXIMIZE_VERTICAL)
- {
- /* Remove vertical */
- h = ec->saved.h;
- vert = EINA_TRUE;
- y = ec->saved.y + zone->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 + zone->x;
- horiz = EINA_TRUE;
- ec->maximized &= ~E_MAXIMIZE_HORIZONTAL;
- }
+ ec->fullscreen_policy = policy;
- 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;
- }
- }
- evas_object_smart_callback_call(ec->frame, "unmaximize_done", NULL);
- ec->changes.need_unmaximize = 0;
-#endif
+ _e_client_event_simple(ec, E_EVENT_CLIENT_FULLSCREEN);
}
EINTERN void
-e_client_fullscreen(E_Client *ec, E_Fullscreen policy)
+e_client_unfullscreen(E_Client *ec)
{
-#ifdef REFACTOR_ZONE_DESK
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- if ((ec->shaded) || (ec->shading) || (ec->fullscreen)) return;
+ ec->need_fullscreen = 0;
- // call the fullscreen_pre hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_FULLSCREEN_PRE, ec);
+ if (!ec->fullscreen) return;
- ec->fullscreen_policy = policy;
+ ec->fullscreen = 0;
- // call the fullscreen hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_FULLSCREEN, ec);
+ E_Fullscreen policy = ec->fullscreen_policy;
- _e_client_event_simple(ec, E_EVENT_CLIENT_FULLSCREEN);
-#else
- int x, y, w, h;
- E_Zone *zone;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
-
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return;
-
- if ((ec->shaded) || (ec->shading) || (ec->fullscreen)) return;
-
- _e_client_hook_call(E_CLIENT_HOOK_FULLSCREEN_PRE, ec);
-
- if (ec->skip_fullscreen) return;
- if (!ec->desk->visible) return;
- if (ec->new_client)
- {
- ec->need_fullscreen = 1;
- return;
- }
- if (e_comp->nocomp_ec && (ec->desk == e_comp->nocomp_ec->desk))
- e_comp->nocomp_ec = ec;
- ec->desk->fullscreen_clients = eina_list_append(ec->desk->fullscreen_clients, ec);
- ec->pre_res_change.valid = 0;
-
- if (ec->maximized)
- {
- x = ec->saved.x;
- y = ec->saved.y;
- w = ec->saved.w;
- h = ec->saved.h;
- }
- else
- {
- ec->saved.x = ec->client.x - zone->x;
- ec->saved.y = ec->client.y - zone->y;
- ec->saved.w = ec->client.w;
- ec->saved.h = ec->client.h;
- }
- ec->saved.maximized = ec->maximized;
- ec->saved.zone = zone->num;
-
- if (ec->maximized)
- {
- e_client_unmaximize(ec, E_MAXIMIZE_BOTH);
- ec->saved.x = x;
- ec->saved.y = y;
- ec->saved.w = w;
- ec->saved.h = h;
- }
-
- ec->saved.layer = ec->layer;
- e_client_layer_set(ec, E_LAYER_CLIENT_FULLSCREEN);
-
- ec->fullscreen = 1;
- if ((eina_list_count(e_comp->zones) > 1) ||
- (policy == E_FULLSCREEN_RESIZE))
- {
- e_client_frame_geometry_set(ec, zone->x, zone->y, zone->w, zone->h);
- }
- else if (policy == E_FULLSCREEN_ZOOM)
- {
- /* compositor backends! */
- evas_object_smart_callback_call(ec->frame, "fullscreen_zoom", NULL);
- }
-
- if (!e_client_util_ignored_get(ec))
- _e_client_frame_update(ec);
- ec->fullscreen_policy = policy;
- evas_object_smart_callback_call(ec->frame, "fullscreen", NULL);
-
- _e_client_event_simple(ec, E_EVENT_CLIENT_FULLSCREEN);
-#endif
-}
-
-EINTERN void
-e_client_unfullscreen(E_Client *ec)
-{
-#ifdef REFACTOR_ZONE_DESK
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
-
- if ((ec->shaded) || (ec->shading)) return;
- if (!ec->fullscreen) return;
-
- // call the unfullscreen hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_UNFULLSCREEN, ec);
-
- _e_client_event_simple(ec, E_EVENT_CLIENT_UNFULLSCREEN);
-#else
- E_Zone *zone;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
-
- zone = e_comp_zone_find_by_ec(ec);
- if (!zone) return;
- if ((ec->shaded) || (ec->shading)) return;
- if (!ec->fullscreen) return;
- ec->pre_res_change.valid = 0;
- ec->fullscreen = 0;
- ec->need_fullscreen = 0;
- ec->desk->fullscreen_clients = eina_list_remove(ec->desk->fullscreen_clients, ec);
-
- if (ec->fullscreen_policy == E_FULLSCREEN_ZOOM)
- evas_object_smart_callback_call(ec->frame, "unfullscreen_zoom", NULL);
-
- if (!e_client_util_ignored_get(ec))
- _e_client_frame_update(ec);
- ec->fullscreen_policy = 0;
- evas_object_smart_callback_call(ec->frame, "unfullscreen", NULL);
- e_client_util_move_resize_without_frame(ec, zone->x + ec->saved.x,
- zone->y + ec->saved.y,
- ec->saved.w, ec->saved.h);
-
- if (ec->saved.maximized)
- e_client_maximize(ec, (e_config->maximize_policy & E_MAXIMIZE_TYPE) |
- ec->saved.maximized);
+ // call the unfullscreen hook of a client
+ wl_signal_emit(&PRI(ec)->events.unfullscreen, &policy);
e_client_layer_set(ec, ec->saved.layer);
- _e_client_event_simple(ec, E_EVENT_CLIENT_UNFULLSCREEN);
+ ec->fullscreen_policy = E_FULLSCREEN_RESIZE;
- if (!ec->desk->fullscreen_clients)
- e_comp_render_queue();
-#endif
+ _e_client_event_simple(ec, E_EVENT_CLIENT_UNFULLSCREEN);
}
///////////////////////////////////////
-#ifdef REFACTOR_ZONE_DESK
EINTERN Eina_Bool
e_client_is_parent_iconify_by_client(E_Client *ec)
-#else
-static Eina_Bool
-_e_client_is_parent_iconify_by_client(E_Client *ec)
-#endif
{
E_Client *parent = ec->parent;
if (!parent) return EINA_FALSE;
ec, ec->iconic, ec->argb, (unsigned int)ec->exp_iconify.not_raise,
ec->exp_iconify.by_client, ec->exp_iconify.type);
- if (ec->shading || ec->iconic) return;
+ if (ec->iconic) return;
if (ec->exp_iconify.skip_iconify && !iconified_by_client) return;
if (ec->exp_iconify.skip_by_remote) return;
if (!cdata || !cdata->mapped)
TRACE_DS_BEGIN(CLIENT:ICONIFY);
-#ifdef REFACTOR_ZONE_DESK
-#else
- e_comp_wl_remote_surface_image_save(ec);
-
- ec->iconic = 1;
- ec->want_focus = ec->take_focus = 0;
- ec->changes.visible = 0;
- if (ec->fullscreen)
- ec->desk->fullscreen_clients = eina_list_remove(ec->desk->fullscreen_clients, ec);
- e_client_comp_hidden_set(ec, 1);
- evas_object_hide(ec->frame);
- e_client_urgent_set(ec, ec->icccm.urgent);
-
- _e_client_event_simple(ec, E_EVENT_CLIENT_ICONIFY);
-
- if (e_config->transient.iconify)
- {
- E_Client *child;
- Eina_List *list = eina_list_clone(ec->transients);
-
- EINA_LIST_FREE(list, child)
- {
- if ((child->exp_iconify.type != E_ICONIFIED_TYPE_ICONIFY_BY_CLIENT) &&
- (_e_client_is_parent_iconify_by_client(child)))
- {
- e_client_iconified_type_set(child, E_ICONIFIED_TYPE_PARENT_ICONIFY_BY_CLIENT);
- child->exp_iconify.by_client = 1;
- e_policy_client_iconic_state_change_send(child, 1);
- }
- e_client_iconify(child);
- }
- }
-
-#endif
-
+ wl_signal_emit(&PRI(ec)->events.iconify, NULL);
_e_client_hook_call(E_CLIENT_HOOK_ICONIFY, ec);
TRACE_DS_END();
E_API void
e_client_uniconify(E_Client *ec)
{
-#ifdef REFACTOR_ZONE_DESK
E_Comp_Wl_Client_Data *cdata;
E_OBJECT_CHECK(ec);
ec->exp_iconify.by_client, ec->exp_iconify.type,
cdata ? cdata->mapped : 0);
- if (ec->shading || (!ec->iconic)) return;
+ if (!ec->iconic) return;
TRACE_DS_BEGIN(CLIENT:UNICONIFY);
// call the uniconify hook of a client
+ wl_signal_emit(&PRI(ec)->events.uniconify, NULL);
_e_client_hook_call(E_CLIENT_HOOK_UNICONIFY, ec);
TRACE_DS_END();
-#else
- E_Desk *desk;
- Eina_Bool not_raise;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
-
- E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
-
- ELOGF("TZVIS", "UNICONIFY|iconic:%d |argb:%d |not_raise:%d |by_client:%d, type:%d |mapped:%d",
- ec, ec->iconic, ec->argb, (unsigned int)ec->exp_iconify.not_raise,
- ec->exp_iconify.by_client, ec->exp_iconify.type,
- cdata ? cdata->mapped : 0);
-
- if (ec->shading || (!ec->iconic)) return;
-
- TRACE_DS_BEGIN(CLIENT:UNICONIFY);
-
- e_comp_wl_remote_surface_image_save_cancel(ec);
-
- desk = e_desk_current_get(ec->desk->zone);
- e_client_desk_set(ec, desk);
- not_raise = ec->exp_iconify.not_raise;
-
- ec->exp_iconify.by_client = 0;
- e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
-
- if (e_config->transient.iconify)
- {
- E_Client *child;
- Eina_List *list = eina_list_clone(ec->transients);
-
- EINA_LIST_FREE(list, child)
- {
- if (e_client_transient_policy_get(child) == E_TRANSIENT_BELOW)
- {
- child->exp_iconify.not_raise = not_raise;
- e_client_uniconify(child);
- }
- }
- }
-
- if (!not_raise)
- e_client_raise(ec);
-
- if (ec->internal)
- {
- ELOGF("TZVIS", "UNICONIFY|internal object force show", ec);
- evas_object_show(ec->frame);
- }
-
- if (ec->pixmap)
- {
- if (e_pixmap_usable_get(ec->pixmap))
- {
- if (cdata && cdata->mapped)
- {
- ELOGF("TZVIS", "UNICONIFY|object show. frame_visible:%d", ec, evas_object_visible_get(ec->frame));
- evas_object_show(ec->frame);
- }
- else
- {
- ELOGF("TZVIS", "UNICONIFY|object no show. currently unmapped", ec);
- }
- }
- else
- {
- if (!ec->exp_iconify.buffer_flush &&
- !ec->exp_iconify.deiconify_update)
- {
- if (cdata && cdata->mapped)
- {
- ELOGF("TZVIS", "UNICONIFY|object show. no use buffer flush. frame_visible:%d", ec, evas_object_visible_get(ec->frame));
- evas_object_show(ec->frame);
- }
- }
- }
- }
- e_client_comp_hidden_set(ec, 0);
- ec->deskshow = ec->iconic = 0;
-
-#if 0 // focus should be set to the top window not uniconify window
- if (ec->pixmap && e_pixmap_usable_get(ec->pixmap))
- e_client_frame_focus_set(ec, EINA_TRUE);
-#endif
-
- _e_client_event_simple(ec, E_EVENT_CLIENT_UNICONIFY);
-
- if (e_config->transient.iconify)
- {
- E_Client *child;
- Eina_List *list = eina_list_clone(ec->transients);
-
- EINA_LIST_FREE(list, child)
- {
- if (e_client_transient_policy_get(child) == E_TRANSIENT_ABOVE)
- {
- if (child->exp_iconify.type == E_ICONIFIED_TYPE_PARENT_ICONIFY_BY_CLIENT)
- e_policy_client_iconic_state_change_send(child, 0);
- child->exp_iconify.not_raise = not_raise;
- e_client_uniconify(child);
- }
- }
- }
-
- _e_client_hook_call(E_CLIENT_HOOK_UNICONIFY, ec);
-
- ec->exp_iconify.not_raise = 0;
-
- TRACE_DS_END();
-#endif
}
E_API void
///////////////////////////////////////
-EINTERN void
-e_client_urgent_set(E_Client *ec, Eina_Bool urgent)
+EINTERN void e_client_hide_by_request_set(E_Client *ec, Eina_Bool set)
{
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
+ API_ENTRY;
+ priv->hide_by_request = set;
+}
- urgent = !!urgent;
- if (urgent == ec->urgent) return;
- _e_client_event_property(ec, E_CLIENT_PROPERTY_URGENCY);
- if (urgent && (!ec->focused) && (!ec->want_focus))
- {
- e_comp_object_signal_emit(ec->frame, "e,state,urgent", "e");
- ec->urgent = urgent;
- }
- else
- {
- e_comp_object_signal_emit(ec->frame, "e,state,not_urgent", "e");
- ec->urgent = 0;
- }
+EINTERN Eina_Bool e_client_hide_by_request_get(E_Client *ec)
+{
+ API_ENTRY_VAL(EINA_FALSE);
+ return priv->hide_by_request;
+}
+
+EINTERN void e_client_focus_check_set(E_Client *ec, Eina_Bool set)
+{
+ API_ENTRY;
+ priv->focus_check = set;
+}
+
+EINTERN Eina_Bool e_client_focus_check_get(E_Client *ec)
+{
+ API_ENTRY_VAL(EINA_FALSE);
+ return priv->focus_check;
}
///////////////////////////////////////
EINTERN void
e_client_stick(E_Client *ec)
{
-#ifdef REFACTOR_ZONE_DESK
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
if (ec->sticky) return;
// call the stick hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_STICK, ec);
+ wl_signal_emit(&PRI(ec)->events.stick, NULL);
// send the sticky property event of a client
_e_client_event_property(ec, E_CLIENT_PROPERTY_STICKY);
-#else
- E_Desk *desk;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- if (ec->sticky) return;
- desk = ec->desk;
- ec->desk = NULL;
- ec->sticky = 1;
- ec->hidden = 0;
- e_client_desk_set(ec, desk);
- evas_object_smart_callback_call(ec->frame, "stick", NULL);
-
- if (e_config->transient.desktop)
- {
- E_Client *child;
- Eina_List *list = eina_list_clone(ec->transients);
-
- EINA_LIST_FREE(list, child)
- {
- child->sticky = 1;
- evas_object_show(ec->frame);
- }
- }
-
- _e_client_event_property(ec, E_CLIENT_PROPERTY_STICKY);
-#endif
}
EINTERN void
e_client_unstick(E_Client *ec)
{
-#ifdef REFACTOR_ZONE_DESK
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
if (!ec->sticky) return;
// call the unstick hook of a client
- _e_client_hook_call(E_CLIENT_HOOK_UNSTICK, ec);
+ wl_signal_emit(&PRI(ec)->events.unstick, NULL);
// send the sticky property event of a client
_e_client_event_property(ec, E_CLIENT_PROPERTY_STICKY);
-#else
- E_Desk *desk;
- E_Zone *zone;
-
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- /* Set the desk before we unstick the client */
- if (!ec->sticky) return;
-
- zone = e_comp_zone_find_by_ec(ec);
- desk = e_desk_current_get(zone);
- ec->desk = NULL;
- ec->hidden = ec->sticky = 0;
- e_client_desk_set(ec, desk);
- evas_object_smart_callback_call(ec->frame, "unstick", NULL);
-
- if (e_config->transient.desktop)
- {
- E_Client *child;
- Eina_List *list = eina_list_clone(ec->transients);
-
- EINA_LIST_FREE(list, child)
- {
- child->sticky = 0;
- }
- }
-
- _e_client_event_property(ec, E_CLIENT_PROPERTY_STICKY);
-
- e_client_desk_set(ec, e_desk_current_get(zone));
-#endif
}
EINTERN void
///////////////////////////////////////
-EINTERN Eina_Bool
-e_client_border_set(E_Client *ec, const char *name)
-{
- Eina_Stringshare *pborder;
-
- E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
- E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
- if (!e_comp_object_frame_allowed(ec->frame)) return EINA_FALSE;
- if (ec->border.changed)
- CRI("CALLING WHEN border.changed SET!");
-
- if (!e_util_strcmp(ec->border.name, name)) return EINA_TRUE;
- if (ec->mwm.borderless && name && strcmp(name, "borderless"))
- {
- CRI("border change attempted for MWM borderless client!");
- }
- pborder = ec->border.name;
- ec->border.name = eina_stringshare_add(name);
- if (e_comp_object_frame_theme_set(ec->frame, name))
- {
- eina_stringshare_del(pborder);
- return EINA_TRUE;
- }
- eina_stringshare_del(ec->border.name);
- ec->border.name = pborder;
- return EINA_FALSE;
-}
-
///////////////////////////////////////
EINTERN void
_e_client_action_init(ec);
_e_client_action_move_timeout_add();
+
+ wl_signal_emit(&PRI(ec)->events.move_update, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_MOVE_UPDATE, ec)) return;
evas_object_freeze_events_set(ec->frame, 1);
{
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- if (ec->lock_user_size || ec->shaded || ec->shading) return;
+ if (ec->lock_user_size) return;
if (e_client_util_resizing_get(ec) || (ec->moving)) return;
if (ev)
{
EINTERN Eina_Bool
e_client_resize_begin(E_Client *ec)
{
- if ((ec->shaded) || (ec->shading) ||
- (ec->fullscreen) || (ec->lock_user_size))
+ if ((ec->fullscreen) || (ec->lock_user_size))
goto error;
if (!_e_client_action_input_win_new()) goto error;
ecresize = ec;
ec->manage_resize.aw = ec->w;
ec->manage_resize.ah = ec->h - ec->manage_resize.header_h - ec->manage_resize.footer_h;
}
+
+ wl_signal_emit(&PRI(ec)->events.move_begin, NULL);
_e_client_hook_call(E_CLIENT_HOOK_RESIZE_BEGIN, ec);
if (ec->transformed)
_e_client_transform_resize_begin(ec);
EINTERN void
e_client_resize_limit(E_Client *ec, int *w, int *h)
{
- double a;
- Eina_Bool inc_h;
-
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- inc_h = (*h - ec->h > 0);
if (ec->frame)
e_comp_object_frame_wh_unadjust(ec->frame, *w, *h, w, h);
if (*h < 1) *h = 1;
if (*w < 1) *w = 1;
- if ((ec->icccm.base_w >= 0) &&
- (ec->icccm.base_h >= 0))
- {
- int tw, th;
-
- tw = *w - ec->icccm.base_w;
- th = *h - ec->icccm.base_h;
- if (tw < 1) tw = 1;
- if (th < 1) th = 1;
- a = (double)(tw) / (double)(th);
- if ((ec->icccm.min_aspect != 0.0) &&
- (a < ec->icccm.min_aspect))
- {
- if (inc_h)
- tw = th * ec->icccm.min_aspect;
- else
- th = tw / ec->icccm.max_aspect;
- *w = tw + ec->icccm.base_w;
- *h = th + ec->icccm.base_h;
- }
- else if ((ec->icccm.max_aspect != 0.0) &&
- (a > ec->icccm.max_aspect))
- {
- tw = th * ec->icccm.max_aspect;
- *w = tw + ec->icccm.base_w;
- }
- }
- else
- {
- a = (double)*w / (double)*h;
- if ((ec->icccm.min_aspect != 0.0) &&
- (a < ec->icccm.min_aspect))
- {
- if (inc_h)
- *w = *h * ec->icccm.min_aspect;
- else
- *h = *w / ec->icccm.min_aspect;
- }
- else if ((ec->icccm.max_aspect != 0.0) &&
- (a > ec->icccm.max_aspect))
- *w = *h * ec->icccm.max_aspect;
- }
- if (ec->icccm.step_w > 0)
- {
- if (ec->icccm.base_w >= 0)
- *w = ec->icccm.base_w +
- (((*w - ec->icccm.base_w) / ec->icccm.step_w) *
- ec->icccm.step_w);
- else
- *w = ec->icccm.min_w +
- (((*w - ec->icccm.min_w) / ec->icccm.step_w) *
- ec->icccm.step_w);
- }
- if (ec->icccm.step_h > 0)
- {
- if (ec->icccm.base_h >= 0)
- *h = ec->icccm.base_h +
- (((*h - ec->icccm.base_h) / ec->icccm.step_h) *
- ec->icccm.step_h);
- else
- *h = ec->icccm.min_h +
- (((*h - ec->icccm.min_h) / ec->icccm.step_h) *
- ec->icccm.step_h);
- }
-
- if (*h < 1) *h = 1;
- if (*w < 1) *w = 1;
if ((ec->icccm.max_w > 0) && (*w > ec->icccm.max_w)) *w = ec->icccm.max_w;
else if (*w < ec->icccm.min_w)
return _e_client_under_pointer_input_helper(desk, x, y);
}
-EINTERN E_Client *
-e_client_input_rect_under_pointer_get(E_Desk *desk, E_Client *exclude)
-{
- int x, y;
-
- /* We need to ensure that we can get the comp window for the
- * zone of either the given desk or the desk of the excluded
- * window, so return if neither is given */
- if (desk)
- e_input_device_pointer_xy_get(NULL, &x, &y);
- else if (exclude)
- e_input_device_pointer_xy_get(NULL, &x, &y);
- else
- return NULL;
-
- if (!desk)
- {
- desk = exclude->desk;
- if (!desk)
- {
- if (exclude->zone)
- desk = e_desk_current_get(exclude->zone);
- else
- desk = e_desk_current_get(e_zone_current_get());
- }
- }
-
- return desk ? _e_client_input_rect_under_pointer_helper(desk, exclude, x, y) : NULL;
-}
-
////////////////////////////////////////////
////////////////////////////////////////////
if (set)
{
e_client_frame_recalc(ec);
+
+ wl_signal_emit(&PRI(ec)->events.redirect, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_REDIRECT, ec)) return;
}
else
{
+ wl_signal_emit(&PRI(ec)->events.unredirect, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_UNREDIRECT, ec)) return;
}
e_comp_object_redirected_set(ec->frame, set);
////////////////////////////////////////////
-EINTERN Eina_Bool
-e_client_is_stacking(const E_Client *ec)
-{
- return e_comp->layers[e_comp_canvas_layer_map(ec->layer)].obj == ec->frame;
-}
-
-////////////////////////////////////////////
-
E_API void
e_client_transform_update(E_Client *ec)
{
if (!ec) return;
if (ec->new_client) return;
if (!_e_client_transform_core_check_change(ec)) return;
- if (!ec->transform_core.activate) return;
if (ec->transform_core.transform_list || ec->transform_core.parent.enable)
{
_e_client_transform_core_sub_update(ec, &ec->transform_core.result.vertices);
if (!e_object_is_del(E_OBJECT(ec)))
- _e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
+ {
+ wl_signal_emit(&PRI(ec)->events.transform_change, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
+ }
}
else
{
_e_client_transform_core_sub_update(ec, NULL);
if (!e_object_is_del(E_OBJECT(ec)))
- _e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
+ {
+ wl_signal_emit(&PRI(ec)->events.transform_change, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
+ }
}
}
EINA_SAFETY_ON_NULL_RETURN(ec);
if (eina_stringshare_replace(&ec->icccm.window_role, role))
- _e_client_hook_call(E_CLIENT_HOOK_WINDOW_ROLE_CHANGE, ec);
+ {
+ wl_signal_emit(&PRI(ec)->events.window_role_change, NULL);
+ _e_client_hook_call(E_CLIENT_HOOK_WINDOW_ROLE_CHANGE, ec);
+ }
}
EINTERN Eina_Bool
goto use_configured;
}
+ if (!e_appinfo_base_output_resolution_available_get(eai))
+ {
+ ELOGF("POL_APPINFO", "NO AVAILABLE BASE SCREEN RESOLUTION... QUERY base_output_resolution", ec);
+ e_policy_base_output_resolution_info_update(ec->netwm.pid);
+ }
+
if (!e_appinfo_base_output_resolution_get(eai, &width, &height))
{
ELOGF("POL_APPINFO", "NO BASE SCREEN RESOLUTION... USE configured_output_resolution(%d,%d) pid:%d", ec,
}
}
+static void
+_e_input_thread_client_layer_set(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec(%p), layer(%d)\n", __func__, ec_data->ec, ec_data->layer);
+ e_input_thread_client_layer_set(e_input_thread_client_get(ec_data->ec), ec_data->layer);
+}
+
+EINTERN void
+e_client_input_thread_layer_set(E_Client *ec, E_Layer layer)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ ec_data.ec = ec;
+ ec_data.layer = layer;
+
+ INF("[%s] ec(%p), layer(%d)\n", __func__, ec, layer);
+ e_input_thread_safe_call(_e_input_thread_client_layer_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+}
+
E_API Eina_Bool
e_client_layer_set(E_Client *ec,
E_Layer layer)
if (e_comp_canvas_client_layer_map(layer) == 9999)
return EINA_FALSE; //invalid layer is not allowed
+#ifdef REFACTOR_DESK_AREA
+#else
if (ec->desk_area.enable)
{
if (e_client_layer_set_by_desk_area(ec, layer))
}
}
ec->desk_area.layer_backup = layer;
+#endif
evas_object_layer_set(ec->frame, layer);
if (ec->layer != layer)
if (ec->layer_pending || ec->layer_block)
{
ec->layer = layer;
+ e_client_input_thread_layer_set(ec, layer);
return EINA_TRUE;
}
}
+ wl_signal_emit(&PRI(ec)->events.set_layer, NULL);
+
return EINA_TRUE;
}
return ec->layer;
}
+#ifdef REFACTOR_DESK_AREA
+#else
static void
_e_client_desk_area_original_layer_save(E_Client *ec, E_Layer layer)
{
// Do we need to check ec->desk_area.enable?
// if ec->desk_area.enable is true, then e_client_layer_set calls
- // e_desk_area_ec_layer_set(). that's too bad. :(
+ // e_desk_area_ec_edg_layer_set(). that's too bad. :(
// so, we MUST make a policy for ordering of the desk group layer restore
// and the desk group enable.
if (ec->desk_area.enable) return;
return ec->desk_area.edgc_layer;
}
-EINTERN Eina_Bool
-e_client_desk_area_enable_set(E_Client *ec, Eina_Bool enable)
-{
- E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
- E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
-
- ec->desk_area.enable = enable;
-
- ELOGF("EDG", "Desk group enable set to %d", ec, enable);
- if (enable)
- {
- if (!ec->desk_area.transform)
- {
- ec->desk_area.transform = e_util_transform_new();
- e_util_transform_role_set(ec->desk_area.transform, "desk_area");
- }
- }
- else
- {
- if (ec->desk_area.transform)
- {
- e_util_transform_del(ec->desk_area.transform);
- ec->desk_area.transform = NULL;
- }
- }
-
- e_desk_area_ec_update(ec->desk_area.desk_area, ec);
- return EINA_TRUE;
-}
-
+//FIXME: use e_desk_area_ec_reassign(eda, ec) instead of this api
E_API Eina_Bool
e_client_desk_area_set(E_Client *ec, E_Desk_Area *eda)
{
return EINA_TRUE;
}
+#endif
static void
_raise_between_sibling_under_parent(E_Client *ec)
{
if (!ec) return;
+#ifdef REFACTOR_DESK_AREA
+#else
if (ec->desk_area.enable)
{
E_Desk_Area *eda;
return;
}
}
+#endif
if (ec->parent && e_client_is_belong_to_parent(ec))
_raise_belong_to_parent(ec);
else
evas_object_raise(ec->frame);
+
+ wl_signal_emit(&PRI(ec)->events.raise, NULL);
}
static void
{
if (!ec) return;
+#ifdef REFACTOR_DESK_AREA
+#else
if (ec->desk_area.enable)
{
E_Desk_Area *eda;
if (eda)
{
e_desk_area_ec_lower(eda, ec);
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_LOWER, ec);
-#endif
+
+ wl_signal_emit(&PRI(ec)->events.lower, NULL);
return;
}
}
+#endif
if (ec->parent && e_client_is_belong_to_parent(ec))
_lower_belong_to_parent(ec);
else
evas_object_lower(ec->frame);
-#ifdef REFACTOR_FOCUS_POLICY
- _e_client_hook_call(E_CLIENT_HOOK_LOWER, ec);
-#endif
+ wl_signal_emit(&PRI(ec)->events.lower, NULL);
}
E_API void
if (!above) return;
if (!above->frame) return;
+#ifdef REFACTOR_DESK_AREA
+#else
if (ec->desk_area.enable)
{
E_Desk_Area *eda;
return;
}
}
+#endif
evas_object_stack_above(ec->frame, above->frame);
+
+ wl_signal_emit(&PRI(ec)->events.stack_above, NULL);
}
E_API void
if (!below) return;
if (!below->frame) return;
+#ifdef REFACTOR_DESK_AREA
+#else
if (ec->desk_area.enable)
{
E_Desk_Area *eda;
return;
}
}
+#endif
evas_object_stack_below(ec->frame, below->frame);
+
+ wl_signal_emit(&PRI(ec)->events.stack_below, NULL);
}
E_API int
return EINA_TRUE;
}
-#ifdef REFACTOR_ZONE_DESK
EINTERN Eina_Bool
e_client_intercept_hook_auto_placement_call(E_Client *ec)
{
_e_client_event_simple(ec, E_EVENT_CLIENT_UNICONIFY);
}
+
+EINTERN void
+e_client_stack_transient_for_done_notify(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ wl_signal_emit(&PRI(ec)->events.stack_transient_for_done, NULL);
+}
+
+#ifdef REFACTOR_DESK_AREA
+EINTERN void
+e_client_subsurface_stack_update(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ wl_signal_emit(&PRI(ec)->events.subsurface_stack_update, ec);
+}
#endif
EINTERN void
+e_client_eval_pre_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_pre_fetch, listener);
+}
+
+EINTERN void
+e_client_eval_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_fetch, listener);
+}
+
+EINTERN void
+e_client_eval_pre_post_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_pre_post_fetch, listener);
+}
+
+EINTERN void
+e_client_eval_post_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_post_fetch, listener);
+}
+
+EINTERN void
+e_client_eval_pre_frame_assign_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_pre_frame_assign, listener);
+}
+
+EINTERN void
+e_client_eval_post_frame_assign_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_post_frame_assign, listener);
+}
+
+EINTERN void
+e_client_eval_pre_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_pre_new_client, listener);
+}
+
+EINTERN void
+e_client_eval_post_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_post_new_client, listener);
+}
+
+EINTERN void
+e_client_eval_visibility_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_visibility, listener);
+}
+
+EINTERN void
+e_client_eval_visibility_end_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_visibility_end, listener);
+}
+
+EINTERN void
+e_client_eval_end_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_end, listener);
+}
+
+EINTERN void
+e_client_move_begin_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move_begin, listener);
+}
+
+EINTERN void
+e_client_move_update_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move_update, listener);
+}
+
+EINTERN void
+e_client_move_end_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move_end, listener);
+}
+
+EINTERN void
+e_client_move_resize_begin_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move_resize_begin, listener);
+}
+
+EINTERN void
+e_client_move_resize_update_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move_resize_update, listener);
+}
+
+EINTERN void
+e_client_move_resize_end_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move_resize_end, listener);
+}
+
+EINTERN void
e_client_destroy_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
wl_signal_add(&priv->events.destroy, listener);
}
-EINTERN struct wl_listener *
-e_client_destroy_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.destroy, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.new_client, listener);
+}
+
+EINTERN void
+e_client_new_client_post_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.new_client_post, listener);
+}
+
+EINTERN void
+e_client_unredirect_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.unredirect, listener);
+}
+
+EINTERN void
+e_client_redirect_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.redirect, listener);
+}
+
+EINTERN void
+e_client_aux_hint_change_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.aux_hint_change, listener);
+}
+
+EINTERN void
+e_client_window_role_change_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.window_role_change, listener);
+}
+
+EINTERN void
+e_client_transform_change_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.transform_change, listener);
+}
+
+EINTERN void
+e_client_activate_done_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.activate_done, listener);
+}
+
+EINTERN void
+e_client_mouse_in_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.mouse_in, listener);
+}
+
+EINTERN void
+e_client_mouse_out_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.mouse_out, listener);
+}
+
+EINTERN void
+e_client_mouse_down_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.mouse_down, listener);
+}
+
+EINTERN void
+e_client_focus_set_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.focus_set, listener);
+}
+
+EINTERN void
+e_client_focus_unset_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.focus_unset, listener);
+}
+
+EINTERN void
+e_client_focus_defer_set_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.focus_defer_set, listener);
+}
+
+EINTERN void
+e_client_focus_latest_set_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.focus_latest_set, listener);
+}
+
+EINTERN void
+e_client_iconify_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.iconify, listener);
+}
+
+EINTERN void
+e_client_uniconify_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.uniconify, listener);
+}
+
+EINTERN void
+e_client_maximize_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.maximize, listener);
+}
+
+EINTERN void
+e_client_unmaximize_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.unmaximize, listener);
+}
+
+EINTERN void
+e_client_fullscreen_pre_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.fullscreen_pre, listener);
+}
+
+EINTERN void
+e_client_fullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.fullscreen, listener);
+}
+
+EINTERN void
+e_client_unfullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.unfullscreen, listener);
+}
+
+EINTERN void
+e_client_move_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.move, listener);
+}
+
+EINTERN void
+e_client_raise_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.raise, listener);
+}
+
+EINTERN void
+e_client_lower_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.lower, listener);
+}
+
+EINTERN void
+e_client_stack_below_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.stack_below, listener);
+}
+
+EINTERN void
+e_client_stack_above_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.stack_above, listener);
+}
+
+EINTERN void
+e_client_set_layer_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.set_layer, listener);
+}
+
+EINTERN void
+e_client_stack_transient_for_done_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.stack_transient_for_done, listener);
+}
+
+EINTERN void
+e_client_stick_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.stick, listener);
+}
+
+EINTERN void
+e_client_unstick_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.unstick, listener);
+}
+
+EINTERN struct wl_listener *
+e_client_destroy_listener_get(E_Client *ec, wl_notify_func_t notify)
+{
+ API_ENTRY_VAL(NULL);
+ return wl_signal_get(&priv->events.destroy, notify);
+}
+
+#ifdef REFACTOR_DESK_AREA
+EINTERN void
+e_client_get_above_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.get_above, listener);
+}
+
+EINTERN void
+e_client_get_below_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.get_below, listener);
+}
+
+EINTERN void
+e_client_get_visible_above_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.get_visible_above, listener);
+}
+
+EINTERN void
+e_client_get_visible_below_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.get_visible_below, listener);
+}
+
+EINTERN void
+e_client_subsurface_stack_update_listener_add(E_Client *ec, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.subsurface_stack_update, listener);
+}
+#endif
+
+EINTERN void
+e_client_shell_configure_send(E_Client *ec, uint32_t edges, int32_t width, int32_t height)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if ((!ec->comp_data->shell.surface) ||
+ (!ec->comp_data->shell.configure_send))
+ return;
+
+ ec->comp_data->shell.configure_send(ec->comp_data->shell.surface, edges, width, height);
+}
+
+EINTERN void
+e_client_shell_configure(E_Client *ec, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if ((!ec->comp_data->shell.surface) ||
+ (!ec->comp_data->shell.configure))
+ return;
+
+ ec->comp_data->shell.configure(ec->comp_data->shell.surface, x, y, width, height);
+}
+
+EINTERN void
+e_client_shell_ping(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if ((!ec->comp_data->shell.surface) ||
+ (!ec->comp_data->shell.ping))
+ return;
+
+ ec->comp_data->shell.ping(ec->comp_data->shell.surface);
+}
+
+static void
+_e_input_thread_client_icccm_name_set(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec(%p), name(%s)\n", __func__, ec_data->ec, ec_data->icccm_name);
+ e_input_thread_client_icccm_name_set(e_input_thread_client_get(ec_data->ec), ec_data->icccm_name);
+}
+
+EINTERN void
+e_client_icccm_name_set(E_Client *ec, const char *name)
+{
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ if (eina_stringshare_replace(&ec->icccm.name, name))
+ {
+ ec->changes.title = EINA_TRUE;
+
+ ec_data.ec = ec;
+ ec_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+ ec_data.is_video = EINA_FALSE;
+
+ if (name)
+ strncpy(ec_data.icccm_name, name, sizeof(ec_data.icccm_name)-1);
+
+ INF("[%s] ec(%p), surface(%p), name(%s)\n", __func__, ec, ec_data.wl_surface, name);
+ e_input_thread_safe_call(_e_input_thread_client_icccm_name_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+ }
+}
+
+E_API Eina_Stringshare *
+e_client_icccm_name_get(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
+
+ return ec->icccm.name;
+}
+
+static void
+_e_input_thread_client_netwm_name_set(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec(%p), name(%p)\n", __func__, ec_data->ec, ec_data->netwm_name);
+ e_input_thread_client_netwm_name_set(e_input_thread_client_get(ec_data->ec), ec_data->netwm_name);
+}
+
+EINTERN void
+e_client_netwm_name_set(E_Client *ec, const char *name)
+{
+ E_Input_Thread_Request_EClient_Data ec_data = { NULL, NULL, EINA_FALSE, EINA_FALSE };
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ eina_stringshare_replace(&ec->netwm.name, name);
+
+ ec_data.ec = ec;
+ ec_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+
+ if (name)
+ strncpy(ec_data.netwm_name, name, sizeof(ec_data.netwm_name)-1);
+
+ INF("[%s] ec(%p), surface(%p), name(%s)\n", __func__, ec, ec_data.wl_surface, ec_data.netwm_name);
+ e_input_thread_safe_call(_e_input_thread_client_netwm_name_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+}
+
+E_API Eina_Stringshare *
+e_client_netwm_name_get(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
+
+ return ec->netwm.name;
+}
+
+static void
+_e_input_thread_client_icccm_title_set(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec(%p), title(%s)\n", __func__, ec_data->ec, ec_data->icccm_title);
+ e_input_thread_client_icccm_title_set(e_input_thread_client_get(ec_data->ec), ec_data->icccm_title);
+}
+
+EINTERN void
+e_client_icccm_title_set(E_Client *ec, const char *title)
+{
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ if (eina_stringshare_replace(&ec->icccm.title, title))
+ {
+ ec->changes.title = EINA_TRUE;
+
+ ec_data.ec = ec;
+ ec_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+ if (title)
+ strncpy(ec_data.icccm_title, title, sizeof(ec_data.icccm_title)-1);
+
+ INF("[%s] ec(%p), surface(%p)\n", __func__, ec, ec_data.wl_surface);
+ e_input_thread_safe_call(_e_input_thread_client_icccm_title_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+ }
+}
+
+E_API Eina_Stringshare *
+e_client_icccm_title_get(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
+
+ return ec->icccm.title;
+}
+
+static void
+_e_client_shell_map(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if ((!ec->comp_data->shell.surface) ||
+ (!ec->comp_data->shell.map))
+ return;
+
+ ec->comp_data->shell.map(ec->comp_data->shell.surface);
+}
+
+EINTERN void
+e_client_shell_unmap(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if ((!ec->comp_data->shell.surface) ||
+ (!ec->comp_data->shell.unmap))
+ return;
+
+ ec->comp_data->shell.unmap(ec->comp_data->shell.surface);
+}
+
+EINTERN void
+e_client_show(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if (ec->comp_data->mapped)
+ return;
+
+ if ((ec->comp_data->shell.surface) && (ec->comp_data->shell.map) &&
+ (!ec->ignored))
+ {
+ ELOGF("E_CLIENT", "Map.", ec);
+ _e_client_shell_map(ec);
+ }
+ else if (ec->internal || e_comp_wl_subsurface_can_show(ec) ||
+ (ec == e_comp_wl->drag_client))
+ {
+ ELOGF("E_CLIENT", "Map. internal:%d, drag:%d",
+ ec, ec->internal, (ec == e_comp_wl->drag_client));
+ ec->visible = EINA_TRUE;
+ ec->ignored = 0;
+ evas_object_show(ec->frame);
+ ec->comp_data->mapped = 1;
+ }
+}
+
+EINTERN void
+e_client_hide(E_Client *ec)
+{
+ API_ENTRY;
+
+ EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
+
+ if (!ec->comp_data->mapped)
+ return;
+
+ if ((ec->comp_data->shell.surface) && (ec->comp_data->shell.unmap))
+ {
+ ELOGF("E_CLIENT", "Unmap", ec);
+
+ if (priv->hide_by_request)
+ ELOGF("COMP", "Currenlty hide_by_request state.", ec);
+
+ if (ec->show_pending.count > 0)
+ {
+ ELOGF("E_CLIENT", "Reset show_pending!!! (count:%d, run:%d)", ec, ec->show_pending.count, ec->show_pending.running);
+ ec->show_pending.count = 0;
+ if (ec->show_pending.running)
+ {
+ // need to send visibility false;
+ e_client_visibility_set(ec, E_VISIBILITY_UNOBSCURED);
+ ELOGF("POL_VIS", "CLIENT VIS ON (fake). argb:%d, opaque:%2d", ec, ec->argb, ec->visibility.opaque);
+ EC_CHANGED(ec);
+ }
+ ec->show_pending.running = EINA_FALSE;
+ }
+ e_client_shell_unmap(ec);
+ }
+ else if ((ec->internal) || (e_comp_wl_subsurface_check(ec)) ||
+ (ec == e_comp_wl->drag_client))
+ {
+ ELOGF("E_CLIENT", "Unmap. internal:%d, sub:%p, drag:%d",
+ ec, ec->internal, ec->comp_data->sub.data, (ec == e_comp_wl->drag_client));
+ ec->visible = EINA_FALSE;
+ evas_object_hide(ec->frame);
+ ec->comp_data->mapped = 0;
+ }
+}
+
+static void
+_e_input_thread_client_video_mode_set(void *data)
+{
+ E_Input_Thread_Request_EClient_Data *ec_data = data;
+ EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+ INF("[input thread|%s] ec(%p), is_video(%d)\n", __func__, ec_data->ec, ec_data->is_video);
+ e_input_thread_client_video_set(e_input_thread_client_get(ec_data->ec), ec_data->is_video);
+}
+
+EINTERN void
+e_client_video_mode_set(E_Client *ec, Eina_Bool is_video)
+{
+ E_Input_Thread_Request_EClient_Data ec_data;
+ memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+ EINA_SAFETY_ON_NULL_RETURN(ec->hwc_window);
+
+ ec->hwc_window->is_video = is_video;
+
+ ec_data.ec = ec;
+ ec_data.is_video = is_video;
+
+ INF("[%s] ec(%p), is_video(%d)\n", __func__, ec, is_video);
+ e_input_thread_safe_call(_e_input_thread_client_video_mode_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
}
projects / platform / upstream / enlightenment.git / blobdiff