-#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 wl_signal move;
- struct wl_signal layer_set;
+ struct wl_signal set_layer;
struct wl_signal raise;
struct wl_signal lower;
struct wl_signal stack_below;
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_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;
wl_signal_init(&priv->events.fullscreen);
wl_signal_init(&priv->events.unfullscreen);
wl_signal_init(&priv->events.move);
- wl_signal_init(&priv->events.layer_set);
+ 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_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);
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);
+ e_client_netwm_name_set(ec, NULL);
E_FREE_FUNC(ec->frame, evas_object_del);
e_uuid_store_entry_del(ec->uuid);
+ 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);
}
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_del(E_Client *ec)
{
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);
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);
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)
ec->moving = 1;
ecmove = ec;
- wl_signal_emit_mutable(&PRI(ec)->events.move_begin, NULL);
+ 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_mutable(&PRI(ec)->events.move_end, NULL);
+ 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_mutable(&PRI(ec)->events.move_resize_end, NULL);
+ wl_signal_emit(&PRI(ec)->events.move_resize_end, NULL);
_e_client_hook_call(E_CLIENT_HOOK_RESIZE_END, ec);
if (ec->transformed)
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;
}
if (ec->moving || (ecmove == ec))
{
- wl_signal_emit_mutable(&PRI(ec)->events.move_resize_update, NULL);
+ wl_signal_emit(&PRI(ec)->events.move_resize_update, NULL);
_e_client_hook_call(E_CLIENT_HOOK_MOVE_UPDATE, ec);
}
ec->pre_cb.x = x; ec->pre_cb.y = y;
- wl_signal_emit_mutable(&PRI(ec)->events.move, NULL);
+ wl_signal_emit(&PRI(ec)->events.move, NULL);
e_comp_visibility_calculation_set(EINA_TRUE);
}
if (e_client_util_resizing_get(ec) || (ecresize == ec))
{
- wl_signal_emit_mutable(&PRI(ec)->events.move_resize_update, NULL);
+ 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_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);
}
if (cdata && cdata->aux_hint.changed)
{
- wl_signal_emit_mutable(&PRI(ec)->events.aux_hint_change, NULL);
+ 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)
TRACE_DS_BEGIN(CLIENT:EVAL);
- wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_new_client, NULL);
+ 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();
if ((ec->new_client) && (!e_client_util_ignored_get(ec)))
{
- wl_signal_emit_mutable(&PRI(ec)->events.eval_post_new_client, NULL);
+ 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();
}
}
- /* 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;
}
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;
if (ec->changes.need_maximize)
e_client_transform_core_update(ec);
- wl_signal_emit_mutable(&PRI(ec)->events.eval_end, NULL);
+ wl_signal_emit(&PRI(ec)->events.eval_end, NULL);
_e_client_hook_call(E_CLIENT_HOOK_EVAL_END, ec);
TRACE_DS_END();
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
#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_mutable(&PRI(ec)->events.eval_visibility, NULL);
+ 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);
}
+EINTERN E_Visibility
+e_client_visibility_get(E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ec, E_VISIBILITY_UNKNOWN);
+
+ return ec->visibility.obscured;
+}
+
+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);
+
+ 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);
+}
+
+EINTERN void
+e_client_visibility_set(E_Client *ec, E_Visibility visibility)
+{
+ 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 (e_client_visibility_get(ec) == visibility) return;
+
+ ec->visibility.obscured = visibility;
+
+ ec_data.ec = ec;
+ ec_data.visibility = ec->visibility.obscured;
+
+ 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));
+}
+
static Eina_Bool
_e_client_transform_core_check_change(E_Client *ec)
{
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_set(obj, map);
+ current_map = e_comp_object_map_get(obj);
- if (ec->transform_core.activate)
+ 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);
- e_map_free(map);
+ 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_set(obj, map);
+ current_map = e_comp_object_map_get(obj);
- if (ec->transform_core.activate)
+ 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);
- e_map_free(map);
+ 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
// call hooks to decide what to do - maybe move/resize
if (ec->ignored || (!ec->changed)) continue;
- wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_fetch, NULL);
+ 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_mutable(&PRI(ec)->events.eval_fetch, NULL);
+ 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)
}
/* PRE_POST_FETCH calls e_remember apply for new client */
- wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_post_fetch, NULL);
+ 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_mutable(&PRI(ec)->events.eval_post_fetch, NULL);
+ 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_mutable(&PRI(ec)->events.eval_pre_frame_assign, NULL);
+ 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_mutable(&PRI(ec)->events.eval_post_frame_assign, NULL);
+ 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);
+ 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);
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->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_mutable(&PRI(ec)->events.new_client, NULL);
+ 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);
}
- wl_signal_emit_mutable(&PRI(ec)->events.new_client_post, NULL);
+ 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;
}
ec->mouse.current.my = y;
ec->mouse.in = 1;
- wl_signal_emit_mutable(&PRI(ec)->events.mouse_in, NULL);
+ wl_signal_emit(&PRI(ec)->events.mouse_in, NULL);
}
EINTERN void
ec->mouse.current.my = y;
ec->mouse.in = 0;
- wl_signal_emit_mutable(&PRI(ec)->events.mouse_out, NULL);
+ wl_signal_emit(&PRI(ec)->events.mouse_out, NULL);
}
EINTERN void
ec->mouse.current.mx = output->x;
ec->mouse.current.my = output->y;
- wl_signal_emit_mutable(&PRI(ec)->events.mouse_down, NULL);
+ wl_signal_emit(&PRI(ec)->events.mouse_down, NULL);
}
EINTERN void
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;
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;
g_rec_mutex_unlock(&e_comp->ec_list_mutex);
return NULL;
+#endif
+}
+
+EINTERN E_Client *
+e_client_visible_above_get(E_Client *ec)
+{
+#ifdef REFACTOR_DESK_AREA
+ API_ENTRY_VAL(NULL);
+
+ E_Client_Data_Get_Visible_Above data;
+
+ 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++)
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--)
g_rec_mutex_unlock(&e_comp->ec_list_mutex);
return NULL;
+#endif
}
EINTERN unsigned int
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- wl_signal_emit_mutable(&PRI(ec)->events.focus_latest_set, NULL);
+ wl_signal_emit(&PRI(ec)->events.focus_latest_set, NULL);
}
E_API void
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- wl_signal_emit_mutable(&PRI(ec)->events.focus_defer_set, NULL);
+ wl_signal_emit(&PRI(ec)->events.focus_defer_set, NULL);
}
EINTERN void
{
// FIXME: Remove focus_unset event of client.
// Instead, make zone focus_unset event and use it.
- wl_signal_emit_mutable(&PRI(focused_ec)->events.focus_unset, NULL);
+ 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);
}
}
}
// 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_mutable(&PRI(ec)->events.focus_set, NULL);
+ 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
ec->exp_iconify.by_client = 0;
e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
- wl_signal_emit_mutable(&PRI(ec)->events.activate_done, NULL);
+ wl_signal_emit(&PRI(ec)->events.activate_done, NULL);
_e_client_hook_call(E_CLIENT_HOOK_ACTIVATE_DONE, ec);
TRACE_DS_END();
///////////////////////////////////////
EINTERN void
-e_client_shade(E_Client *ec, E_Direction dir)
+e_client_maximized_geometry_set(E_Client *ec, int x, int y, int w, int h)
{
- 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;
+ if (!ec) return;
ec->maximized_info.x = x;
ec->maximized_info.y = y;
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))
if (!ec->fullscreen)
{
// call the maximize hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.maximize, &max);
+ wl_signal_emit(&PRI(ec)->events.maximize, &max);
// store the E_Maximize value
ec->maximized = max;
ec->changes.need_unmaximize = 0;
-
- evas_object_smart_callback_call(ec->frame, "maximize_done", NULL);
}
else
{
return;
}
- if ((ec->shaded) || (ec->shading)) return;
-
/* Remove directions not used */
max &= (ec->maximized & E_MAXIMIZE_DIRECTION);
/* Can only remove existing maximization directions */
if (!ec->fullscreen)
{
- evas_object_smart_callback_call(ec->frame, "unmaximize_pre", NULL);
-
// call the unmaximize hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.unmaximize, &max);
-
- evas_object_smart_callback_call(ec->frame, "unmaximize_done", NULL);
+ wl_signal_emit(&PRI(ec)->events.unmaximize, &max);
}
ec->maximized = E_MAXIMIZE_NONE;
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- if ((ec->shaded) || (ec->shading) || (ec->fullscreen)) return;
+ if (ec->fullscreen) return;
// call the fullscreen_pre hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.fullscreen_pre, NULL);
+ wl_signal_emit(&PRI(ec)->events.fullscreen_pre, NULL);
_e_client_hook_call(E_CLIENT_HOOK_FULLSCREEN_PRE, ec);
if (ec->skip_fullscreen) return;
ec->fullscreen = 1;
// call the fullscreen hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.fullscreen, &policy);
+ wl_signal_emit(&PRI(ec)->events.fullscreen, &policy);
ec->fullscreen_policy = policy;
ec->need_fullscreen = 0;
- if ((ec->shaded) || (ec->shading)) return;
if (!ec->fullscreen) return;
ec->fullscreen = 0;
E_Fullscreen policy = ec->fullscreen_policy;
// call the unfullscreen hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.unfullscreen, &policy);
+ wl_signal_emit(&PRI(ec)->events.unfullscreen, &policy);
e_client_layer_set(ec, ec->saved.layer);
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);
- wl_signal_emit_mutable(&PRI(ec)->events.iconify, NULL);
+ wl_signal_emit(&PRI(ec)->events.iconify, NULL);
_e_client_hook_call(E_CLIENT_HOOK_ICONIFY, ec);
TRACE_DS_END();
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_mutable(&PRI(ec)->events.uniconify, NULL);
+ wl_signal_emit(&PRI(ec)->events.uniconify, NULL);
_e_client_hook_call(E_CLIENT_HOOK_UNICONIFY, ec);
TRACE_DS_END();
return priv->hide_by_request;
}
-EINTERN void
-e_client_urgent_set(E_Client *ec, Eina_Bool urgent)
+EINTERN void e_client_focus_check_set(E_Client *ec, Eina_Bool set)
{
- E_OBJECT_CHECK(ec);
- E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
+ API_ENTRY;
+ priv->focus_check = 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_focus_check_get(E_Client *ec)
+{
+ API_ENTRY_VAL(EINA_FALSE);
+ return priv->focus_check;
}
///////////////////////////////////////
if (ec->sticky) return;
// call the stick hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.stick, NULL);
+ 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);
if (!ec->sticky) return;
// call the unstick hook of a client
- wl_signal_emit_mutable(&PRI(ec)->events.unstick, NULL);
+ 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);
///////////////////////////////////////
-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_mutable(&PRI(ec)->events.move_update, NULL);
+ 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.ah = ec->h - ec->manage_resize.header_h - ec->manage_resize.footer_h;
}
- wl_signal_emit_mutable(&PRI(ec)->events.move_begin, NULL);
+ 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)
{
e_client_frame_recalc(ec);
- wl_signal_emit_mutable(&PRI(ec)->events.redirect, NULL);
+ wl_signal_emit(&PRI(ec)->events.redirect, NULL);
if (!_e_client_hook_call(E_CLIENT_HOOK_REDIRECT, ec)) return;
}
else
{
- wl_signal_emit_mutable(&PRI(ec)->events.unredirect, NULL);
+ 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 (!e_object_is_del(E_OBJECT(ec)))
{
- wl_signal_emit_mutable(&PRI(ec)->events.transform_change, NULL);
+ wl_signal_emit(&PRI(ec)->events.transform_change, NULL);
_e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
}
}
if (!e_object_is_del(E_OBJECT(ec)))
{
- wl_signal_emit_mutable(&PRI(ec)->events.transform_change, NULL);
+ wl_signal_emit(&PRI(ec)->events.transform_change, NULL);
_e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
}
}
if (eina_stringshare_replace(&ec->icccm.window_role, role))
{
- wl_signal_emit_mutable(&PRI(ec)->events.window_role_change, NULL);
+ wl_signal_emit(&PRI(ec)->events.window_role_change, NULL);
_e_client_hook_call(E_CLIENT_HOOK_WINDOW_ROLE_CHANGE, ec);
}
}
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_mutable(&PRI(ec)->events.layer_set, NULL);
+ 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)
{
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_mutable(&PRI(ec)->events.raise, NULL);
+ 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;
{
e_desk_area_ec_lower(eda, ec);
- wl_signal_emit_mutable(&PRI(ec)->events.lower, NULL);
+ 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);
- wl_signal_emit_mutable(&PRI(ec)->events.lower, NULL);
+ 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_mutable(&PRI(ec)->events.stack_above, NULL);
+ 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_mutable(&PRI(ec)->events.stack_below, NULL);
+ wl_signal_emit(&PRI(ec)->events.stack_below, NULL);
}
E_API int
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- wl_signal_emit_mutable(&PRI(ec)->events.stack_transient_for_done, NULL);
+ wl_signal_emit(&PRI(ec)->events.stack_transient_for_done, NULL);
}
+#ifdef REFACTOR_DESK_AREA
EINTERN void
-e_client_eval_pre_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_subsurface_stack_update(E_Client *ec)
{
- API_ENTRY;
- wl_signal_add(&priv->events.eval_pre_fetch, listener);
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ wl_signal_emit(&PRI(ec)->events.subsurface_stack_update, ec);
}
+#endif
-EINTERN struct wl_listener *
-e_client_eval_pre_fetch_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_eval_pre_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_pre_fetch, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.eval_pre_fetch, listener);
}
EINTERN void
wl_signal_add(&priv->events.eval_fetch, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_fetch_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_fetch, notify);
-}
-
EINTERN void
e_client_eval_pre_post_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_pre_post_fetch, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_pre_post_fetch_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_pre_post_fetch, notify);
-}
-
EINTERN void
e_client_eval_post_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_post_fetch, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_post_fetch_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_post_fetch, notify);
-}
-
EINTERN void
e_client_eval_pre_frame_assign_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_pre_frame_assign, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_pre_frame_assign_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_pre_frame_assign, notify);
-}
-
EINTERN void
e_client_eval_post_frame_assign_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_post_frame_assign, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_post_frame_assign_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_post_frame_assign, notify);
-}
-
EINTERN void
e_client_eval_pre_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_pre_new_client, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_pre_new_client_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_pre_new_client, notify);
-}
-
EINTERN void
e_client_eval_post_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_post_new_client, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_post_new_client_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_post_new_client, notify);
-}
-
EINTERN void
e_client_eval_visibility_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_visibility, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_visibility_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_visibility, notify);
-}
-
EINTERN void
e_client_eval_visibility_end_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_visibility_end, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_visibility_end_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_visibility_end, notify);
-}
-
EINTERN void
e_client_eval_end_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.eval_end, listener);
}
-EINTERN struct wl_listener *
-e_client_eval_end_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.eval_end, notify);
-}
-
EINTERN void
e_client_move_begin_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.move_begin, listener);
}
-EINTERN struct wl_listener *
-e_client_move_begin_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move_begin, notify);
-}
-
EINTERN void
e_client_move_update_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.move_update, listener);
}
-EINTERN struct wl_listener *
-e_client_move_update_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move_update, notify);
-}
-
EINTERN void
e_client_move_end_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.move_end, listener);
}
-EINTERN struct wl_listener *
-e_client_move_end_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move_end, notify);
-}
-
EINTERN void
e_client_move_resize_begin_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.move_resize_begin, listener);
}
-EINTERN struct wl_listener *
-e_client_move_resize_begin_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move_resize_begin, notify);
-}
-
EINTERN void
e_client_move_resize_update_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.move_resize_update, listener);
}
-EINTERN struct wl_listener *
-e_client_move_resize_update_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move_resize_update, notify);
-}
-
EINTERN void
e_client_move_resize_end_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.move_resize_end, listener);
}
-EINTERN struct wl_listener *
-e_client_move_resize_end_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move_resize_end, notify);
-}
-
EINTERN void
e_client_destroy_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.destroy, 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);
-}
-
EINTERN void
e_client_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.new_client, listener);
}
-EINTERN struct wl_listener *
-e_client_new_client_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.new_client, notify);
-}
-
EINTERN void
e_client_new_client_post_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.new_client_post, listener);
}
-EINTERN struct wl_listener *
-e_client_new_client_post_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.new_client_post, notify);
-}
-
EINTERN void
e_client_unredirect_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.unredirect, listener);
}
-EINTERN struct wl_listener *
-e_client_unredirect_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.unredirect, notify);
-}
-
EINTERN void
e_client_redirect_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.redirect, listener);
}
-EINTERN struct wl_listener *
-e_client_redirect_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.redirect, notify);
-}
-
EINTERN void
e_client_aux_hint_change_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.aux_hint_change, listener);
}
-EINTERN struct wl_listener *
-e_client_aux_hint_change_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.aux_hint_change, notify);
-}
-
EINTERN void
e_client_window_role_change_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.window_role_change, listener);
}
-EINTERN struct wl_listener *
-e_client_window_role_change_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.window_role_change, notify);
-}
-
EINTERN void
e_client_transform_change_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.transform_change, listener);
}
-EINTERN struct wl_listener *
-e_client_transform_change_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.transform_change, notify);
-}
-
EINTERN void
e_client_activate_done_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.activate_done, listener);
}
-EINTERN struct wl_listener *
-e_client_activate_done_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.activate_done, notify);
-}
-
EINTERN void
e_client_mouse_in_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.mouse_in, listener);
}
-EINTERN struct wl_listener *
-e_client_mouse_in_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.mouse_in, notify);
-}
-
EINTERN void
e_client_mouse_out_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.mouse_out, listener);
}
-EINTERN struct wl_listener *
-e_client_mouse_out_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.mouse_out, notify);
-}
-
EINTERN void
e_client_mouse_down_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.mouse_down, listener);
}
-EINTERN struct wl_listener *
-e_client_mouse_down_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.mouse_down, notify);
-}
-
EINTERN void
e_client_focus_set_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.focus_set, listener);
}
-EINTERN struct wl_listener *
-e_client_focus_set_listener_get(E_Client *ec, wl_notify_func_t notify)
-{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.focus_set, notify);
-}
-
EINTERN void
e_client_focus_unset_listener_add(E_Client *ec, struct wl_listener *listener)
{
wl_signal_add(&priv->events.focus_unset, listener);
}
-EINTERN struct wl_listener *
-e_client_focus_unset_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_focus_defer_set_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.focus_unset, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.focus_defer_set, listener);
}
EINTERN void
-e_client_focus_defer_set_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_focus_latest_set_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.focus_defer_set, listener);
+ wl_signal_add(&priv->events.focus_latest_set, listener);
}
-EINTERN struct wl_listener *
-e_client_focus_defer_set_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_iconify_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.focus_defer_set, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.iconify, listener);
}
EINTERN void
-e_client_focus_latest_set_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_uniconify_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.focus_latest_set, listener);
+ wl_signal_add(&priv->events.uniconify, listener);
}
-EINTERN struct wl_listener *
-e_client_focus_latest_set_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_maximize_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.focus_latest_set, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.maximize, listener);
}
EINTERN void
-e_client_iconify_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_unmaximize_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.iconify, listener);
+ wl_signal_add(&priv->events.unmaximize, listener);
}
-EINTERN struct wl_listener *
-e_client_iconify_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_fullscreen_pre_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.iconify, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.fullscreen_pre, listener);
}
EINTERN void
-e_client_uniconify_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_fullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.uniconify, listener);
+ wl_signal_add(&priv->events.fullscreen, listener);
}
-EINTERN struct wl_listener *
-e_client_uniconify_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_unfullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.uniconify, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.unfullscreen, listener);
}
EINTERN void
-e_client_maximize_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_move_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.maximize, listener);
+ wl_signal_add(&priv->events.move, listener);
}
-EINTERN struct wl_listener *
-e_client_maximize_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_raise_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.maximize, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.raise, listener);
}
EINTERN void
-e_client_unmaximize_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_lower_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.unmaximize, listener);
+ wl_signal_add(&priv->events.lower, listener);
}
-EINTERN struct wl_listener *
-e_client_unmaximize_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_stack_below_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.unmaximize, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.stack_below, listener);
}
EINTERN void
-e_client_fullscreen_pre_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_stack_above_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.fullscreen_pre, listener);
+ wl_signal_add(&priv->events.stack_above, listener);
}
-EINTERN struct wl_listener *
-e_client_fullscreen_pre_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_set_layer_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.fullscreen_pre, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.set_layer, listener);
}
EINTERN void
-e_client_fullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_stack_transient_for_done_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.fullscreen, listener);
+ wl_signal_add(&priv->events.stack_transient_for_done, listener);
}
-EINTERN struct wl_listener *
-e_client_fullscreen_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_stick_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.fullscreen, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.stick, listener);
}
EINTERN void
-e_client_unfullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_unstick_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.unfullscreen, listener);
+ wl_signal_add(&priv->events.unstick, listener);
}
EINTERN struct wl_listener *
-e_client_unfullscreen_listener_get(E_Client *ec, wl_notify_func_t notify)
+e_client_destroy_listener_get(E_Client *ec, wl_notify_func_t notify)
{
API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.unfullscreen, notify);
+ return wl_signal_get(&priv->events.destroy, notify);
}
+#ifdef REFACTOR_DESK_AREA
EINTERN void
-e_client_move_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_get_above_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.move, listener);
+ wl_signal_add(&priv->events.get_above, listener);
}
-EINTERN struct wl_listener *
-e_client_move_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_get_below_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.move, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.get_below, listener);
}
EINTERN void
-e_client_raise_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_get_visible_above_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.raise, listener);
+ wl_signal_add(&priv->events.get_visible_above, listener);
}
-EINTERN struct wl_listener *
-e_client_raise_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_get_visible_below_listener_add(E_Client *ec, struct wl_listener *listener)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.raise, notify);
+ API_ENTRY;
+ wl_signal_add(&priv->events.get_visible_below, listener);
}
EINTERN void
-e_client_lower_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_subsurface_stack_update_listener_add(E_Client *ec, struct wl_listener *listener)
{
API_ENTRY;
- wl_signal_add(&priv->events.lower, listener);
+ wl_signal_add(&priv->events.subsurface_stack_update, listener);
}
+#endif
-EINTERN struct wl_listener *
-e_client_lower_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_shell_configure_send(E_Client *ec, uint32_t edges, int32_t width, int32_t height)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.lower, notify);
+ 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_stack_below_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_shell_configure(E_Client *ec, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height)
{
- API_ENTRY;
- wl_signal_add(&priv->events.stack_below, listener);
+ 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 struct wl_listener *
-e_client_stack_below_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_shell_ping(E_Client *ec)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.stack_below, notify);
+ 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_stack_above_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_icccm_name_set(E_Client *ec, const char *name)
{
- API_ENTRY;
- wl_signal_add(&priv->events.stack_above, listener);
+ 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));
+ }
}
-EINTERN struct wl_listener *
-e_client_stack_above_listener_get(E_Client *ec, wl_notify_func_t notify)
+E_API Eina_Stringshare *
+e_client_icccm_name_get(E_Client *ec)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.stack_above, notify);
+ 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_layer_set_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_netwm_name_set(E_Client *ec, const char *name)
{
- API_ENTRY;
- wl_signal_add(&priv->events.layer_set, listener);
+ 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));
}
-EINTERN struct wl_listener *
-e_client_layer_set_listener_get(E_Client *ec, wl_notify_func_t notify)
+E_API Eina_Stringshare *
+e_client_netwm_name_get(E_Client *ec)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.layer_set, notify);
+ 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_stack_transient_for_done_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_icccm_title_set(E_Client *ec, const char *title)
{
- API_ENTRY;
- wl_signal_add(&priv->events.stack_transient_for_done, listener);
+ 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));
+ }
}
-EINTERN struct wl_listener *
-e_client_stack_transient_for_done_listener_get(E_Client *ec, wl_notify_func_t notify)
+E_API Eina_Stringshare *
+e_client_icccm_title_get(E_Client *ec)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.stack_transient_for_done, notify);
+ 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_stick_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_shell_unmap(E_Client *ec)
{
- API_ENTRY;
- wl_signal_add(&priv->events.stick, listener);
+ 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 struct wl_listener *
-e_client_stick_listener_get(E_Client *ec, wl_notify_func_t notify)
+EINTERN void
+e_client_show(E_Client *ec)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.stick, notify);
+ 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_unstick_listener_add(E_Client *ec, struct wl_listener *listener)
+e_client_hide(E_Client *ec)
{
API_ENTRY;
- wl_signal_add(&priv->events.unstick, listener);
+
+ 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;
+ }
}
-EINTERN struct wl_listener *
-e_client_unstick_listener_get(E_Client *ec, wl_notify_func_t notify)
+static void
+_e_input_thread_client_video_mode_set(void *data)
{
- API_ENTRY_VAL(NULL);
- return wl_signal_get(&priv->events.unstick, notify);
+ 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