#include "e_comp_wl_subsurface_intern.h"
#include "e_comp_object_intern.h"
#include "e_map_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
+#include "e_view_rect.h"
struct _E_Alpha_Mask_Rect
{
- Evas_Object *eo;
+ E_View_Rect *view;
E_Map *map;
E_Client *ec;
E_Comp_Wl_Hook *subsurface_create_hook;
struct wl_listener destroy;
struct wl_listener transform_change;
+ struct wl_listener show;
+ struct wl_listener hide;
+ struct wl_listener reposition;
+ struct wl_listener resize;
};
static void _e_alpha_mask_rect_destroy(E_Alpha_Mask_Rect *rect);
e_map_util_points_populate_from_object_full(rect->map, rect->ec->frame, 0);
- evas_object_geometry_get(rect->eo, NULL, NULL, &w, &h);
+ e_view_rect_size_get(rect->view, &w, &h);
e_map_point_image_uv_set(rect->map, 0, 0, 0);
e_map_point_image_uv_set(rect->map, 1, w, 0);
e_map_point_image_uv_set(rect->map, 2, w, h);
e_map_point_image_uv_set(new_map, 2, w, h);
e_map_point_image_uv_set(new_map, 3, 0, h);
- e_comp_object_map_set(rect->eo, new_map);
- e_comp_object_map_enable_set(rect->eo, EINA_TRUE);
+ e_view_map_set(e_view_rect_view_get(rect->view), new_map);
+ e_view_map_enable_set(e_view_rect_view_get(rect->view), true);
e_map_free(new_map);
}
else
{
- e_comp_object_map_set(rect->eo, rect->map);
- e_comp_object_map_enable_set(rect->eo, EINA_TRUE);
+ e_view_map_set(e_view_rect_view_get(rect->view), rect->map);
+ e_view_map_enable_set(e_view_rect_view_get(rect->view), true);
}
if (map) e_map_free(map);
}
static void
-_e_alpha_mask_rect_cb_frame_show(void *data, Evas *evas EINA_UNUSED, Evas_Object *eo EINA_UNUSED, void *event EINA_UNUSED)
+_e_alpha_mask_rect_cb_view_client_show(struct wl_listener *listener, void *data)
{
- E_Alpha_Mask_Rect *rect = data;
+ E_Alpha_Mask_Rect *rect = wl_container_of(listener, rect, show);
- evas_object_show(rect->eo);
+ e_view_show(e_view_rect_view_get(rect->view));
}
static void
-_e_alpha_mask_rect_cb_frame_hide(void *data, Evas *evas EINA_UNUSED, Evas_Object *eo EINA_UNUSED, void *event EINA_UNUSED)
+_e_alpha_mask_rect_cb_view_client_hide(struct wl_listener *listener, void *data)
{
- E_Alpha_Mask_Rect *rect = data;
+ E_Alpha_Mask_Rect *rect = wl_container_of(listener, rect, hide);
- evas_object_hide(rect->eo);
+ e_view_hide(e_view_rect_view_get(rect->view));
}
static void
-_e_alpha_mask_rect_cb_frame_move(void *data, Evas *evas EINA_UNUSED, Evas_Object *eo EINA_UNUSED, void *event EINA_UNUSED)
+_e_alpha_mask_rect_cb_view_client_reposition(struct wl_listener *listener, void *data)
{
- E_Alpha_Mask_Rect *rect = data;
+ E_Alpha_Mask_Rect *rect = wl_container_of(listener, rect, reposition);
- evas_object_move(rect->eo, rect->ec->x, rect->ec->y);
+ e_view_position_set(e_view_rect_view_get(rect->view), rect->ec->x, rect->ec->y);
_e_alpha_mask_rect_map_apply(rect);
}
static void
-_e_alpha_mask_rect_cb_frame_resize(void *data, Evas *evas EINA_UNUSED, Evas_Object *eo EINA_UNUSED, void *event EINA_UNUSED)
+_e_alpha_mask_rect_cb_view_client_resize(struct wl_listener *listener, void *data)
{
- E_Alpha_Mask_Rect *rect = data;
+ E_Alpha_Mask_Rect *rect = wl_container_of(listener, rect, resize);
_e_alpha_mask_rect_map_apply(rect);
}
e_comp_wl_hook_del(rect->subsurface_create_hook);
evas_object_smart_callback_del(rect->ec->frame, "client_resize", _e_alpha_mask_rect_cb_client_resize);
- evas_object_event_callback_del(rect->ec->frame, EVAS_CALLBACK_SHOW, _e_alpha_mask_rect_cb_frame_show);
- evas_object_event_callback_del(rect->ec->frame, EVAS_CALLBACK_HIDE, _e_alpha_mask_rect_cb_frame_hide);
- evas_object_event_callback_del(rect->ec->frame, EVAS_CALLBACK_MOVE, _e_alpha_mask_rect_cb_frame_move);
- evas_object_event_callback_del(rect->ec->frame, EVAS_CALLBACK_RESIZE, _e_alpha_mask_rect_cb_frame_resize);
- evas_object_del(rect->eo);
- e_map_free(rect->map);
+ wl_list_remove(&rect->show.link);
+ wl_list_remove(&rect->hide.link);
+ wl_list_remove(&rect->reposition.link);
+ wl_list_remove(&rect->resize.link);
wl_list_remove(&rect->transform_change.link);
wl_list_remove(&rect->destroy.link);
+ e_view_destroy(e_view_rect_view_get(rect->view));
+ e_map_free(rect->map);
free(rect);
}
e_alpha_mask_rect_create(E_Client *ec)
{
E_Alpha_Mask_Rect *rect;
- short layer;
+ E_View_Client *view_client;
+ E_View_Tree *parent;
+ E_View *view;
+ const int color[4] = {0, 0, 0, 0};
rect = E_NEW(E_Alpha_Mask_Rect, 1);
if (!rect)
return NULL;
- rect->eo = evas_object_rectangle_add(e_comp->evas);
- if (!rect->eo)
+ view_client = e_client_view_get(ec);
+ parent = e_view_parent_get(e_view_client_view_get(view_client));
+ rect->view = e_view_rect_create(parent, 1, 1, color);
+ if (!rect->view)
{
free(rect);
return NULL;
if (!rect->map)
{
ERR("Failed to new e_map ec:%p", ec);
- evas_object_del(rect->eo);
+ e_view_destroy(e_view_rect_view_get(rect->view));
free(rect);
return NULL;
}
+ view = e_view_rect_view_get(rect->view);
+
/* This object doesn't care about mouse event. And It's also
* to avoid events of mouse on the E_Client. */
- evas_object_pass_events_set(rect->eo, EINA_TRUE);
-
- layer = evas_object_layer_get(ec->frame);
- evas_object_layer_set(rect->eo, layer);
- evas_object_render_op_set(rect->eo, EVAS_RENDER_COPY);
-
- /* It's more reasonable to use the transparent color instead of black because
- * we can show the alpha value of the 24 depth topmost window.
- */
- evas_object_color_set(rect->eo, 0x00, 0x00, 0x00, 0x00);
- evas_object_move(rect->eo, ec->x, ec->y);
- evas_object_resize(rect->eo, 1, 1);
- evas_object_name_set(rect->eo, "below_bg_rectangle");
+ e_view_pass_events_set(view, true);
+ e_view_render_op_set(view, E_VIEW_RENDER_COPY);
+ e_view_position_set(view, ec->x, ec->y);
+ e_view_name_set(view, "below_bg_rectangle");
rect->ec = ec;
_e_alpha_mask_rect_map_apply(rect);
- if (evas_object_visible_get(ec->frame))
- evas_object_show(rect->eo);
+ if (e_view_visible_get(e_view_client_view_get(e_client_view_get(ec))))
+ e_view_show(e_view_rect_view_get(rect->view));
+
+ rect->show.notify = _e_alpha_mask_rect_cb_view_client_show;
+ e_view_show_listener_add(e_view_client_view_get(view_client), &rect->show);
+ rect->hide.notify = _e_alpha_mask_rect_cb_view_client_hide;
+ e_view_hide_listener_add(e_view_client_view_get(view_client), &rect->hide);
+ rect->reposition.notify = _e_alpha_mask_rect_cb_view_client_reposition;
+ e_view_reposition_listener_add(e_view_client_view_get(view_client), &rect->reposition);
+ rect->resize.notify = _e_alpha_mask_rect_cb_view_client_resize;
+ e_view_client_resize_listener_add(view_client, &rect->resize);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _e_alpha_mask_rect_cb_frame_show, rect);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _e_alpha_mask_rect_cb_frame_hide, rect);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_alpha_mask_rect_cb_frame_move, rect);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _e_alpha_mask_rect_cb_frame_resize, rect);
+ // TODO : view
evas_object_smart_callback_add(ec->frame, "client_resize", _e_alpha_mask_rect_cb_client_resize, rect);
rect->subsurface_create_hook = e_comp_wl_hook_add(E_COMP_WL_HOOK_SUBSURFACE_CREATE, _e_alpha_mask_rect_cb_subsurface_create, rect);
/* set alpha only if SW path */
- e_comp_object_alpha_set(ec->frame, EINA_TRUE);
+ e_view_client_alpha_set(view_client, true);
/* force update for changing alpha value. if the native surface has been already
* set before, changing alpha value can't be applied to egl image.
*/
+ // TODO : view
e_comp_object_native_surface_set(ec->frame, EINA_FALSE);
e_pixmap_image_refresh(ec->pixmap);
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(view_client, 0, 0, ec->w, ec->h);
+ e_view_client_dirty(view_client);
+ e_view_client_render(view_client);
e_comp_wl_subsurface_restack(ec);
e_alpha_mask_rect_restack(rect);
EINTERN void
e_alpha_mask_rect_restack(E_Alpha_Mask_Rect *rect)
{
- E_Client *bottom = rect->ec;
+ E_View_Client *view_client;
+ E_View_Tree *parent;
+ E_Client *tmp, *bottom;
+ view_client = e_client_view_get(rect->ec);
+ parent = e_view_parent_get(e_view_client_view_get(view_client));
+ e_view_reparent(e_view_rect_view_get(rect->view), parent);
+
+ bottom = rect->ec;
while (bottom)
{
- short layer = evas_object_layer_get(bottom->frame);
-
- if (evas_object_layer_get(rect->eo) != layer)
- evas_object_layer_set(rect->eo, layer);
+ tmp = eina_list_nth(bottom->comp_data->sub.below_list, 0);
+ if (!tmp)
+ break;
- evas_object_stack_below(rect->eo, bottom->frame);
- bottom = eina_list_nth(bottom->comp_data->sub.below_list, 0);
+ bottom = tmp;
}
+
+ view_client = e_client_view_get(bottom);
+ e_view_place_below(e_view_rect_view_get(rect->view), e_view_client_view_get(view_client));
}
-EINTERN Evas_Object *
-e_alpha_mask_rect_evas_object_get(E_Alpha_Mask_Rect *rect)
+EINTERN E_View *
+e_alpha_mask_rect_view_get(E_Alpha_Mask_Rect *rect)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(rect, NULL);
- return rect->eo;
+ return e_view_rect_view_get(rect->view);
}
#include <Evas.h>
#include "e_client.h"
+#include "e_view.h"
struct _E_Alpha_Mask_Rect;
typedef struct _E_Alpha_Mask_Rect E_Alpha_Mask_Rect;
E_Alpha_Mask_Rect *e_alpha_mask_rect_create(E_Client *ec);
void e_alpha_mask_rect_destroy(E_Alpha_Mask_Rect *rect);
E_Alpha_Mask_Rect *e_alpha_mask_rect_try_from_ec(E_Client *ec);
-Evas_Object *e_alpha_mask_rect_evas_object_get(E_Alpha_Mask_Rect *rect);
+E_View *e_alpha_mask_rect_view_get(E_Alpha_Mask_Rect *rect);
void e_alpha_mask_rect_restack(E_Alpha_Mask_Rect *rect);
#endif
#include "e_comp_intern.h"
#include "e_output_intern.h"
#include "e_client_intern.h"
+#include "e_view_edje_intern.h"
#include "e_zone_intern.h"
#include "e_theme_intern.h"
#include "e_config_intern.h"
#include "e_tizen_screen_manager_intern.h"
#include "e_display_intern.h"
-#include "e_utils_intern.h"
+#include "e_view_intern.h"
static Eina_List *handlers;
static Eina_Bool _ev_freeze = EINA_FALSE;
static void
-_e_comp_canvas_cb_del()
-{
- E_FREE_LIST(handlers, ecore_event_handler_del);
-}
-
-///////////////////////////////////
-
-static void
_e_comp_canvas_render_post(void *data EINA_UNUSED, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
{
E_Client *ec;
}
}
-///////////////////////////////////
-
-static void
-_e_comp_canvas_cb_mouse_in(void *d EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
-{
- /* Do nothing */
- ;
-}
-
-static void
-_e_comp_canvas_cb_mouse_down(void *d EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
-{
- /* Do nothing */
- ;
-}
-
-static void
-_e_comp_canvas_cb_mouse_up(void *d EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
-{
- /* Do nothing */
- ;
-}
-
-static void
-_e_comp_canvas_cb_mouse_wheel(void *d EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
-{
- /* Do nothing */
- ;
-}
-
-////////////////////////////////////
-
static Eina_Bool
_e_comp_cb_zone_change()
{
EINTERN Eina_Bool
e_comp_canvas_init(int w, int h)
{
- Evas_Object *o;
+ E_View_Rect *rect;
+ E_View *view;
+ E_View_Tree *layer_tree;
Eina_List *screens;
- unsigned int r, g, b, a;
- Evas_Render_Op opmode;
+ E_View_Render_Op opmode = E_VIEW_RENDER_BLEND;
+ int color[4] = {0, 0, 0, 255};
E_Zone *zone;
E_Tizen_Screen *tizen_screen;
TRACE_DS_BEGIN(COMP_CANVAS:INIT);
e_comp->evas = ecore_evas_get(e_comp->ee);
+ e_comp->canvas = e_canvas_create(e_comp->evas);
e_comp->w = w;
e_comp->h = h;
- r = g = b = 0;
- a = 255;
- opmode = EVAS_RENDER_BLEND;
-
if (e_config)
{
- r = e_config->comp_canvas_bg.r;
- g = e_config->comp_canvas_bg.g;
- b = e_config->comp_canvas_bg.b;
- a = e_config->comp_canvas_bg.a;
- opmode = e_config->comp_canvas_bg.opmode;
+ color[0] = e_config->comp_canvas_bg.r;
+ color[1] = e_config->comp_canvas_bg.g;
+ color[2] = e_config->comp_canvas_bg.b;
+ color[3] = e_config->comp_canvas_bg.a;
+
+ if (e_config->comp_canvas_bg.opmode == EVAS_RENDER_COPY)
+ opmode = E_VIEW_RENDER_COPY;
}
- o = evas_object_rectangle_add(e_comp->evas);
- e_comp->bg_blank_object = o;
- evas_object_layer_set(o, E_LAYER_BOTTOM);
- evas_object_move(o, 0, 0);
- evas_object_resize(o, e_comp->w, e_comp->h);
- evas_object_color_set(o, r, g, b, a);
+ layer_tree = e_canvas_layer_view_tree_get(e_comp->canvas, E_CANVAS_LAYER_BOTTOM);
+ rect = e_view_rect_create(layer_tree, e_comp->w, e_comp->h, color);
+ e_comp->bg_blank_view = view = e_view_rect_view_get(rect);
+ e_view_position_set(view, 0, 0);
- if (opmode != evas_object_render_op_get(o))
- evas_object_render_op_set(o, opmode);
+ if (opmode != e_view_render_op_get(view))
+ e_view_render_op_set(view, opmode);
- evas_object_name_set(o, "comp->bg_blank_object");
- evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_DOWN, (Evas_Object_Event_Cb)_e_comp_canvas_cb_mouse_down, NULL);
- evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_UP, (Evas_Object_Event_Cb)_e_comp_canvas_cb_mouse_up, NULL);
- evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_IN, (Evas_Object_Event_Cb)_e_comp_canvas_cb_mouse_in, NULL);
- evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_WHEEL, (Evas_Object_Event_Cb)_e_comp_canvas_cb_mouse_wheel, NULL);
- evas_object_event_callback_add(o, EVAS_CALLBACK_DEL, _e_comp_canvas_cb_del, NULL);
- evas_object_show(o);
+ e_view_name_set(view, "comp->bg_blank_view");
+ e_view_show(view);
ecore_evas_name_class_set(e_comp->ee, "E", "Comp_EE");
ecore_evas_show(e_comp->ee);
return EINA_TRUE;
}
+E_API E_Canvas *
+e_comp_canvas_get(void)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp, NULL);
+
+ return e_comp->canvas;
+}
+
EINTERN void
e_comp_canvas_clear(void)
{
+ E_FREE_LIST(handlers, ecore_event_handler_del);
+
+ e_view_destroy(e_comp->bg_blank_view);
+ e_canvas_destroy(e_comp->canvas);
evas_event_freeze(e_comp->evas);
edje_freeze();
- E_FREE_FUNC(e_comp->fps_fg, evas_object_del);
- E_FREE_FUNC(e_comp->fps_bg, evas_object_del);
+ E_FREE_FUNC(e_comp->fps_fg, e_view_destroy);
+ E_FREE_FUNC(e_comp->fps_bg, e_view_destroy);
E_FREE_FUNC(e_comp->autoclose.rect, evas_object_del);
E_FREE_FUNC(e_comp->pointer, e_object_del);
}
EINTERN void
e_comp_canvas_zone_update(E_Zone *zone)
{
- Evas_Object *o;
+ E_View_Tree *layer_tree;
+ E_View_Edje *view_edje;
+ E_View *view;
const char *const over_styles[] =
{
"e/comp/screen/overlay/default",
if (zone->over && zone->base)
{
- e_theme_edje_object_set(zone->base, "base/theme/comp",
- under_styles[conf->disable_screen_effects]);
- e_theme_edje_object_set(zone->over, "base/theme/comp",
- over_styles[conf->disable_screen_effects]);
+ e_theme_edje_view_set(e_view_edje_from_view(zone->base), "base/theme/comp",
+ under_styles[conf->disable_screen_effects]);
+ e_theme_edje_view_set(e_view_edje_from_view(zone->over), "base/theme/comp",
+ over_styles[conf->disable_screen_effects]);
return;
}
- E_FREE_FUNC(zone->base, evas_object_del);
- E_FREE_FUNC(zone->over, evas_object_del);
- zone->base = o = edje_object_add(e_comp->evas);
- evas_object_repeat_events_set(o, 1);
- evas_object_name_set(zone->base, "zone->base");
- e_theme_edje_object_set(o, "base/theme/comp", under_styles[conf->disable_screen_effects]);
- evas_object_move(o, zone->x, zone->y);
- evas_object_resize(o, zone->w, zone->h);
- evas_object_layer_set(o, E_LAYER_BG);
- evas_object_show(o);
-
- zone->over = o = edje_object_add(e_comp->evas);
- //edje_object_signal_callback_add(o, "e,state,screensaver,active", "e", _e_comp_canvas_screensaver_active, NULL);
- evas_object_layer_set(o, E_LAYER_MAX);
- evas_object_raise(o);
- evas_object_name_set(zone->over, "zone->over");
- evas_object_pass_events_set(o, 1);
- e_theme_edje_object_set(o, "base/theme/comp", over_styles[conf->disable_screen_effects]);
- evas_object_move(o, zone->x, zone->y);
- evas_object_resize(o, zone->w, zone->h);
- evas_object_raise(o);
- evas_object_show(o);
+ E_FREE_FUNC(zone->base, e_view_destroy);
+ E_FREE_FUNC(zone->over, e_view_destroy);
+ layer_tree = e_canvas_layer_view_tree_get(e_comp->canvas, E_CANVAS_LAYER_BG);
+ view_edje = e_view_edje_create(layer_tree);
+ zone->base = view = e_view_edje_view_get(view_edje);
+ e_view_repeat_events_set(view, true);
+ e_view_name_set(view, "zone->base");
+ e_theme_edje_view_set(view_edje, "base/theme/comp", under_styles[conf->disable_screen_effects]);
+ e_view_position_set(view, zone->x, zone->y);
+ e_view_edje_size_set(view_edje, zone->w, zone->h);
+ e_view_show(view);
+
+ layer_tree = e_canvas_layer_view_tree_get(e_comp->canvas, E_CANVAS_LAYER_MAX);
+ view_edje = e_view_edje_create(layer_tree);
+ zone->over = view = e_view_edje_view_get(view_edje);
+ e_view_name_set(view, "zone->over");
+ e_view_pass_events_set(view, true);
+ e_theme_edje_view_set(view_edje, "base/theme/comp", over_styles[conf->disable_screen_effects]);
+ e_view_position_set(view, zone->x, zone->y);
+ e_view_edje_size_set(view_edje, zone->w, zone->h);
+ e_view_raise_to_top(view);
+ e_view_show(view);
}
EINTERN void
EINA_LIST_FOREACH(e_comp->zones, l, zone)
{
- E_FREE_FUNC(zone->base, evas_object_del);
- E_FREE_FUNC(zone->over, evas_object_del);
+ E_FREE_FUNC(zone->base, e_view_destroy);
+ E_FREE_FUNC(zone->over, e_view_destroy);
e_comp_canvas_zone_update(zone);
}
E_API unsigned int
e_comp_canvas_client_layer_map(E_Layer layer)
{
- return e_util_client_layer_map(layer);
+ switch (layer)
+ {
+ case E_LAYER_CLIENT_DESKTOP: return 0;
+ case E_LAYER_CLIENT_BELOW: return 1;
+ case E_LAYER_CLIENT_NORMAL: return 2;
+ case E_LAYER_CLIENT_ABOVE: return 3;
+ case E_LAYER_CLIENT_EDGE: return 4;
+ case E_LAYER_CLIENT_FULLSCREEN: return 5;
+ case E_LAYER_CLIENT_EDGE_FULLSCREEN: return 6;
+ case E_LAYER_CLIENT_POPUP: return 7;
+ case E_LAYER_CLIENT_TOP: return 8;
+ case E_LAYER_CLIENT_PRIO: return 9;
+ case E_LAYER_CLIENT_NOTIFICATION_LOW: return 10;
+ case E_LAYER_CLIENT_NOTIFICATION_NORMAL: return 11;
+ case E_LAYER_CLIENT_NOTIFICATION_HIGH: return 12;
+ case E_LAYER_CLIENT_NOTIFICATION_TOP: return 13;
+ case E_LAYER_CLIENT_ALERT_LOW: return 14;
+ case E_LAYER_CLIENT_ALERT: return 15;
+ case E_LAYER_CLIENT_ALERT_HIGH: return 16;
+ case E_LAYER_CLIENT_DRAG: return 17;
+ case E_LAYER_CLIENT_CURSOR: return 18;
+ default: break;
+ }
+ return 9999;
}
EINTERN E_Layer
#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_zone_intern.h"
#include "e_config_intern.h"
#include "e_input_thread_client_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#define PRI(ec) ((E_Client_Private *)e_object_data_get(E_OBJECT(ec)))
E_Aot_Type aot_type;
E_Client *modal;
+
+ E_View_Client *view_client;
};
static int _e_client_hooks_delete = 0;
new_y += (new_h - org_h);
/* step 5: set geometry to new value */
- evas_object_geometry_set(ec->frame, new_x, new_y, new_w, new_h);
+ e_view_position_set(e_view_client_view_get(PRI(ec)->view_client), new_x, new_y);
+ e_view_client_size_set(PRI(ec)->view_client, new_w, new_h);
}
void
eina_stringshare_replace(&ec->icccm.window_role, NULL);
e_client_netwm_name_set(ec, NULL);
+ e_view_destroy(e_view_client_view_get(PRI(ec)->view_client));
E_FREE_FUNC(ec->frame, evas_object_del);
E_OBJECT(ec)->references--;
if (!stopping)
{
e_client_comp_hidden_set(ec, 1);
- evas_object_pass_events_set(ec->frame, 1);
+ e_view_pass_events_set(e_view_client_view_get(PRI(ec)->view_client), true);
}
E_FREE_FUNC(ec->ping_poller, ecore_poller_del);
if (e_config->interactive_resize)
{
- evas_object_geometry_set(ec->frame, new_x, new_y, new_w, new_h);
+ e_view_position_set(e_view_client_view_get(PRI(ec)->view_client), new_x, new_y);
+ e_view_client_size_set(PRI(ec)->view_client, new_w, new_h);
}
else
{
}
static Eina_Bool
-_e_client_under_pointer_helper_ignore_client(E_Desk *desk, E_Client *client)
+_e_client_under_pointer_helper_ignore_client(E_Desk *desk, E_Client *ec)
{
/* 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(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;
+ if (e_client_util_ignored_get(ec) || (!e_desk_has_ec(desk, ec))) return EINA_TRUE;
+ if (!e_view_client_visible_get(PRI(ec)->view_client)) return EINA_TRUE;
+ if (e_policy_client_is_cursor(ec)) return EINA_TRUE;
+ if (e_comp_wl->drag_client == ec) return EINA_TRUE;
return EINA_FALSE;
}
_e_client_event_simple(ec, E_EVENT_CLIENT_MOVE);
- evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
+ e_view_position_get(e_view_client_view_get(PRI(ec)->view_client), &x, &y);
if ((e_config->transient.move) && (ec->transients))
{
Eina_List *list = eina_list_clone(ec->transients);
{
if (child->vkbd.vkbd) continue;
- evas_object_move(child->frame,
- child->x + x - ec->pre_cb.x,
- child->y + y - ec->pre_cb.y);
+ e_view_position_set(e_view_client_view_get(PRI(child)->view_client),
+ child->x + x - ec->pre_cb.x,
+ child->y + y - ec->pre_cb.y);
}
}
if (ec->moving || (ecmove == ec))
_e_client_event_simple(ec, E_EVENT_CLIENT_RESIZE);
- evas_object_geometry_get(ec->frame, &x, &y, &w, &h);
+ e_view_client_geometry_get(PRI(ec)->view_client, &x, &y, &w, &h);
if ((e_config->transient.resize) && (ec->transients))
{
Eina_List *list = eina_list_clone(ec->transients);
nh = (child->h * h) / ec->pre_cb.h;
nx += ((nw - child->w) / 2);
ny += ((nh - child->h) / 2);
- evas_object_move(child->frame, nx, ny);
+ e_view_position_set(e_view_client_view_get(PRI(child)->view_client), nx, ny);
}
}
}
if (ec->changes.size)
{
ec->changes.size = 0;
- evas_object_resize(ec->frame, ec->w, ec->h);
+ e_view_client_size_set(PRI(ec)->view_client, ec->w, ec->h);
prop |= E_CLIENT_PROPERTY_SIZE;
}
{
ec->changes.tz_position = 0;
ec->changes.pos = 0;
- evas_object_move(ec->frame, ec->x, ec->y);
+ e_view_position_set(e_view_client_view_get(PRI(ec)->view_client), ec->x, ec->y);
prop |= E_CLIENT_PROPERTY_POS;
}
}
}
- evas_object_show(ec->frame);
- if (evas_object_visible_get(ec->frame))
+ e_view_client_show(PRI(ec)->view_client);
+ if (e_view_client_visible_get(PRI(ec)->view_client))
{
ec->changes.visible = 0;
_e_client_event_show(ec);
if (!ec) return EINA_FALSE;
if (ec->frame)
- evas_object_geometry_get(ec->frame, 0, 0, &w, &h);
+ e_view_client_geometry_get(PRI(ec)->view_client, NULL, NULL, &w, &h);
// check client position or size change
if (ec->x != ec->transform_core.backup.client_x ||
(!ec->changes.pos) &&
(!ec->changes.size))
{
- evas_object_show(ec->frame);
- ec->changes.visible = !evas_object_visible_get(ec->frame);
+ e_view_client_show(PRI(ec)->view_client);
+ ec->changes.visible = !e_view_client_visible_get(PRI(ec)->view_client);
}
}
else
{
- evas_object_hide(ec->frame);
+ e_view_client_hide(PRI(ec)->view_client);
ec->changes.visible = 0;
}
}
if ((ec->changes.visible) && (ec->visible) && (!ec->changed))
{
- evas_object_show(ec->frame);
- ec->changes.visible = !evas_object_visible_get(ec->frame);
+ e_view_client_show(PRI(ec)->view_client);
+ ec->changes.visible = !e_view_client_visible_get(PRI(ec)->view_client);
ec->changed = ec->changes.visible;
e_comp_visibility_calculation_set(EINA_TRUE);
}
e_input_backend_thread_safe_call(_e_input_thread_client_new, &ec_new_data, sizeof(E_Input_Thread_Request_EClient_Data));
}
+static void
+_e_client_view_init(E_Client *ec)
+{
+ E_Client_Private *priv = PRI(ec);
+ E_View_Tree *tree;
+
+ tree = e_canvas_layer_view_tree_get(e_comp->canvas, E_CANVAS_LAYER_CLIENT_NORMAL);
+ if (!tree)
+ return;
+
+ priv->view_client = e_view_client_create(ec, tree);
+}
+
E_API E_Client *
e_client_new(E_Pixmap *cp, int first_map, int internal)
{
e_comp_object_client_add(ec);
if (ec->frame)
{
+ _e_client_view_init(ec);
evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _e_client_cb_evas_show, ec);
evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _e_client_cb_evas_hide, ec);
evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_client_cb_evas_move, ec);
x = zx + zw - w;
if ((y + h) > (zy + zh))
y = zy + zh - h;
- evas_object_geometry_set(ec->frame, x, y, w, h);
+ e_view_position_set(e_view_client_view_get(PRI(ec)->view_client), x, y);
+ e_view_client_size_set(PRI(ec)->view_client, w, h);
}
memcpy(&ec->pre_res_change, &pre_res_change, sizeof(pre_res_change));
}
{
if (ec->frame)
{
- evas_object_geometry_get(ec->frame, &gx, &gy, &gw, &gh);
+ e_view_client_geometry_get(PRI(ec)->view_client, &gx, &gy, &gw, &gh);
if (gw == 0 && gh == 0)
{
/* In this case, there is no image buffer in e_comp_object, thus it
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_view_freeze_events_set(e_view_client_view_get(PRI(ec)->view_client), true);
if (!action_handler_mouse)
action_handler_mouse = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_client_move_mouse_down, NULL);
_e_client_action_init(ec);
_e_client_action_resize_timeout_add();
- evas_object_freeze_events_set(ec->frame, 1);
+ e_view_freeze_events_set(e_view_client_view_get(PRI(ec)->view_client), true);
if (!action_handler_mouse)
action_handler_mouse = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_client_resize_mouse_down, NULL);
return EINA_TRUE;
}
+E_API E_View_Client *
+e_client_view_get(E_Client *ec)
+{
+ E_OBJECT_CHECK_RETURN(ec, NULL);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(PRI(ec)->view_client, NULL);
+
+ return PRI(ec)->view_client;
+}
+
/* change the base_output_resolution of the bind_ec by checking the base_output_resolution of provider_ec's appinfo */
EINTERN Eina_Bool
e_client_base_output_resolution_rsm_update(E_Client *bind_ec, E_Client *provider_ec)
e_client_frame_focus_set(E_Client *ec, Eina_Bool focus)
{
if (!ec) return;
- evas_object_focus_set(ec->frame, focus);
+ e_view_client_focus_set(PRI(ec)->view_client, focus);
}
EINTERN void
if (ec->internal || ec->input_only)
{
- evas_object_geometry_set(ec->frame, x, y, w, h);
+ e_view_position_set(e_view_client_view_get(PRI(ec)->view_client), x, y);
+ e_view_client_size_set(PRI(ec)->view_client, w, h);
}
else
{
ec->move_after_resize = EINA_TRUE;
e_client_pos_set(ec, x, y);
- evas_object_resize(ec->frame, w, h);
+ e_view_client_size_set(PRI(ec)->view_client, w, h);
}
else
- evas_object_geometry_set(ec->frame, x, y, w, h);
+ {
+ e_view_position_set(e_view_client_view_get(PRI(ec)->view_client), x, y);
+ e_view_client_size_set(PRI(ec)->view_client, w, h);
+ }
}
}
E_API void
e_client_util_move_without_frame(E_Client *ec, int x, int y)
{
+ int w, h;
if (!ec) return;
- e_comp_object_frame_xy_adjust(ec->frame, x, y, &x, &y);
- evas_object_move(ec->frame, x, y);
+ e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
+ e_view_client_frame_xy_adjust(e_client_view_get(ec), x, y, &x, &y);
+ e_view_client_geometry_set(e_client_view_get(ec), x, y, w, h);
}
E_API void
e_client_util_resize_without_frame(E_Client *ec, int w, int h)
{
if (!ec) return;
- e_comp_object_frame_wh_adjust(ec->frame, w, h, &w, &h);
- evas_object_resize(ec->frame, w, h);
+ e_view_client_frame_wh_adjust(e_client_view_get(ec), w, h, &w, &h);
+ e_view_client_size_set(e_client_view_get(ec), w, h);
e_client_stay_within_canvas_margin(ec);
}
E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
if (!ec->frame) return EINA_FALSE;
- if (e_util_client_layer_map(layer) == 9999)
+ if (e_comp_canvas_client_layer_map(layer) == 9999)
return EINA_FALSE; //invalid layer is not allowed
- evas_object_layer_set(ec->frame, layer);
+ if (ec->layer != layer)
+ {
+ int w, h;
+ e_view_client_geometry_get(PRI(ec)->view_client, NULL, NULL, &w, &h);
+ e_view_client_geometry_set(PRI(ec)->view_client, ec->x, ec->y, w, h);
+ }
+ e_view_client_layer_set(PRI(ec)->view_client, e_canvas_util_e_layer_map(layer));
if (ec->layer != layer)
{
/* check exceptional case */
E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, E_LAYER_BOTTOM);
if (!ec->frame) return E_LAYER_BOTTOM;
- layer = evas_object_layer_get(ec->frame);
+ layer = e_view_layer_index_get(e_view_client_view_get(PRI(ec)->view_client));
if (ec->layer != layer)
{
/* client could be on temperory layer while pending or block,
ELOGF("LAYER", "layer dismatch ec->layer %d | evas obj layer %d ",
ec, ec->layer, layer);
- if (e_util_client_layer_map(layer) == 9999)
+ if (e_comp_canvas_client_layer_map(layer) == 9999)
return E_LAYER_BOTTOM; //not on E_LAYER_CLIENT
}
if (ec->parent && e_client_is_belong_to_parent(ec))
_raise_belong_to_parent(ec);
else
- evas_object_raise(ec->frame);
+ e_view_raise_to_top(e_view_client_view_get(PRI(ec)->view_client));
wl_signal_emit(&PRI(ec)->events.raise, NULL);
}
if (ec->parent && e_client_is_belong_to_parent(ec))
_lower_belong_to_parent(ec);
else
- evas_object_lower(ec->frame);
+ e_view_lower_to_bottom(e_view_client_view_get(PRI(ec)->view_client));
wl_signal_emit(&PRI(ec)->events.lower, NULL);
}
E_API void
e_client_stack_above(E_Client *ec, E_Client *above)
{
+ E_View *ec_view, *above_view;
+
if (!ec) return;
if (!ec->frame) return;
if (!above) return;
if (!above->frame) return;
- evas_object_stack_above(ec->frame, above->frame);
+ ec_view = e_view_client_view_get(PRI(ec)->view_client);
+ above_view = e_view_client_view_get(PRI(above)->view_client);
+
+ if (e_view_parent_get(ec_view) != e_view_parent_get(above_view))
+ e_view_reparent(ec_view, e_canvas_layer_view_tree_get(e_comp_canvas_get(), e_canvas_layer_find(e_comp_canvas_get(), above_view)));
+
+ e_view_place_above(ec_view , above_view);
wl_signal_emit(&PRI(ec)->events.stack_above, NULL);
}
E_API void
e_client_stack_below(E_Client *ec, E_Client *below)
{
+ E_View *ec_view, *below_view;
+
if (!ec) return;
if (!ec->frame) return;
if (!below) return;
if (!below->frame) return;
- evas_object_stack_below(ec->frame, below->frame);
+ ec_view = e_view_client_view_get(PRI(ec)->view_client);
+ below_view = e_view_client_view_get(PRI(below)->view_client);
+
+ if (e_view_parent_get(ec_view) != e_view_parent_get(below_view))
+ e_view_reparent(ec_view, e_canvas_layer_view_tree_get(e_comp_canvas_get(), e_canvas_layer_find(e_comp_canvas_get(), below_view)));
+
+ e_view_place_below(ec_view, below_view);
wl_signal_emit(&PRI(ec)->events.stack_below, NULL);
}
ec->show_pending.running = EINA_FALSE;
if (ec->frame)
{
- ELOGF("E_CLIENT", "evas_object_show by unset show_pending", ec);
- evas_object_show(ec->frame);
+ ELOGF("E_CLIENT", "e_view_client_show by unset show_pending", ec);
+ e_view_client_show(PRI(ec)->view_client);
//e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
EC_CHANGED(ec);
}
EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(ec->frame, EINA_FALSE);
- evas_object_map_enable_set(ec->frame, enable);
+ e_view_map_enable_set(e_view_client_view_get(PRI(ec)->view_client), enable);
return EINA_TRUE;
}
ec, ec->internal, (ec == e_comp_wl->drag_client));
ec->visible = EINA_TRUE;
ec->ignored = 0;
- evas_object_show(ec->frame);
+ e_view_client_show(PRI(ec)->view_client);
ec->comp_data->mapped = 1;
}
}
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);
+ e_view_client_hide(PRI(ec)->view_client);
ec->comp_data->mapped = 0;
}
}
#include "e_utils_intern.h"
#include "e_comp_wl_subsurface_intern.h"
#include "e_output_intern.h"
-#include "e_comp_object_intern.h"
#include "e_zone_intern.h"
#include "e_config_intern.h"
#include "e_policy_wl_intern.h"
#include "e_policy_intern.h"
#include "e_display_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#ifdef E_DISPLAY
#else
#include "e_comp_screen_intern.h"
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
E_CLIENT_REVERSE_FOREACH(ec)
- if (e_desk_has_ec(desk, ec) && evas_object_visible_get(ec->frame)) return ec;
+ if (e_desk_has_ec(desk, ec) && e_view_client_visible_get(e_client_view_get(ec))) return ec;
return NULL;
}
static void
_e_desk_client_data_del(E_Desk *desk, E_Client *ec)
{
- evas_object_data_del(ec->frame, DESK_EC_DATA_KEY);
+ e_view_data_del(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY);
}
static void
{
E_Desk *data;
- data = evas_object_data_get(ec->frame, DESK_EC_DATA_KEY);
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY);
if (data)
{
if (data == desk)
return;
}
- evas_object_data_del(ec->frame, DESK_EC_DATA_KEY);
+ _e_desk_client_data_del(desk, ec);
}
- evas_object_data_set(ec->frame, DESK_EC_DATA_KEY, desk);
+ e_view_data_set(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY, desk);
}
static void
if (!ec->new_client)
{
- if (ec->frame)
+ if (e_client_view_get(ec))
{
- e_comp_object_effect_unclip(ec->frame);
- e_comp_object_effect_set(ec->frame, NULL);
+ e_view_client_effect_unclip(e_client_view_get(ec));
+ e_view_client_effect_set(e_client_view_get(ec), NULL);
}
if (desk->visible || ec->sticky)
{
if ((!ec->hidden) && (!ec->iconic))
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
}
else
{
ec->hidden = 1;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
}
}
static Eina_Bool
_e_desk_transition_setup(E_Client *ec, int dx, int dy, int state)
{
- e_comp_object_effect_set(ec->frame, "none");
+ e_view_client_effect_set(e_client_view_get(ec), "none");
return EINA_FALSE;
}
static void
-_e_desk_show_end(void *data, Evas_Object *obj EINA_UNUSED, const char *emission EINA_UNUSED, const char *source EINA_UNUSED)
+_e_desk_show_end(void *data, E_View_Client *client, const char *emission, const char *source)
{
E_Client *ec = data;
E_Zone *ec_zone;
ec_desk->animate_count--;
e_client_comp_hidden_set(ec, 0);
- e_comp_object_effect_unclip(ec->frame);
+ e_view_client_effect_unclip(e_client_view_get(ec));
ec->hidden = 0;
- if (!ec->visible) evas_object_show(ec->frame);
+ if (!ec->visible)
+ e_view_client_show(e_client_view_get(ec));
if (ec_desk != e_desk_current_get(ec_zone)) return;
}
static void
-_e_desk_hide_end(void *data, Evas_Object *obj EINA_UNUSED, const char *emission EINA_UNUSED, const char *source EINA_UNUSED)
+_e_desk_hide_end(void *data, E_View_Client *client, const char *emission, const char *source)
{
E_Client *ec = data;
E_Desk *ec_desk;
if (ec_desk)
ec_desk->animate_count--;
ec->hidden = 1;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
}
static void
if (ec->moving)
{
e_desk_client_add(desk, ec);
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
continue;
}
if ((!e_desk_has_ec(desk, ec)) || (ec->sticky)) continue;
if ((!starting) && (!ec->new_client) && _e_desk_transition_setup(ec, dx, dy, 1))
{
- e_comp_object_effect_stop(ec->frame, _e_desk_hide_end);
- e_comp_object_effect_start(ec->frame, _e_desk_show_end, ec);
+ e_view_client_effect_stop(e_client_view_get(ec), _e_desk_hide_end);
+ e_view_client_effect_start(e_client_view_get(ec), _e_desk_show_end, ec);
desk->animate_count++;
}
else
ec->hidden = 0;
e_client_comp_hidden_set(ec, ec->hidden);
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
}
}
if ((!e_desk_has_ec(desk, ec)) || (ec->sticky)) continue;
if ((!starting) && (!ec->new_client) && _e_desk_transition_setup(ec, -dx, -dy, 0))
{
- e_comp_object_effect_stop(ec->frame, _e_desk_show_end);
- e_comp_object_effect_start(ec->frame, _e_desk_hide_end, ec);
+ e_view_client_effect_stop(e_client_view_get(ec), _e_desk_show_end);
+ e_view_client_effect_start(e_client_view_get(ec), _e_desk_hide_end, ec);
desk->animate_count++;
}
else
{
ec->hidden = 1;
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
ec->changes.visible = 0;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
}
e_client_comp_hidden_set(ec, EINA_TRUE);
}
_e_desk_client_deskzoom_set(ec, zoomx, zoomy, cx, cy);
- if (evas_object_visible_get(ec->frame))
+ if (e_view_client_visible_get(e_client_view_get(ec)))
{
// force update
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
}
}
EINA_SAFETY_ON_NULL_RETURN_VAL(desk, EINA_FALSE);
- data = evas_object_data_get(ec->frame, DESK_EC_DATA_KEY);
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY);
if (data == desk) return EINA_TRUE;
return EINA_FALSE;
#include "e_utils_intern.h"
#include "e_comp_intern.h"
#include "e_comp_wl_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include "e_input_thread_client_intern.h"
#include <libds-tizen/screen.h>
static void
_e_desk_area_client_data_del(E_Desk_Area *eda, E_Client *ec)
{
- evas_object_data_del(ec->frame, DESK_AREA_EC_DATA_KEY);
+ e_view_data_del(e_view_client_view_get(e_client_view_get(ec)), DESK_AREA_EC_DATA_KEY);
}
static void
{
E_Desk_Area *data;
- data = evas_object_data_get(ec->frame, DESK_AREA_EC_DATA_KEY);
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), DESK_AREA_EC_DATA_KEY);
if (data)
{
if (data == eda)
return;
}
- evas_object_data_del(ec->frame, DESK_AREA_EC_DATA_KEY);
+ _e_desk_area_client_data_del(eda, ec);
}
- evas_object_data_set(ec->frame, DESK_AREA_EC_DATA_KEY, eda);
+ e_view_data_set(e_view_client_view_get(e_client_view_get(ec)), DESK_AREA_EC_DATA_KEY, eda);
}
static void
if (send_size)
{
- if (e_comp_object_frame_exists(ec->frame))
+ if (e_view_client_frame_exists(e_client_view_get(ec)))
w = ec->client.w, h = ec->client.h;
else
w = ec->w, h = ec->h;
}
if (ec->layer == E_LAYER_CLIENT_CURSOR) return;
- if (e_util_client_layer_map(ec->layer) == 9999) return;
+ if (e_comp_canvas_client_layer_map(ec->layer) == 9999) return;
g_rec_mutex_lock(&e_comp->ec_list_mutex);
}
if (ec_layer == E_LAYER_CLIENT_DESKTOP) return;
- if (e_util_client_layer_map(ec_layer) == 9999) return;
+ if (e_comp_canvas_client_layer_map(ec_layer) == 9999) return;
/* go down the layers until we find one */
x = e_comp_canvas_layer_map(ec_layer);
}
if (ec->layer == E_LAYER_CLIENT_CURSOR) return;
- if (e_util_client_layer_map(ec->layer) == 9999) return;
+ if (e_comp_canvas_client_layer_map(ec->layer) == 9999) return;
g_rec_mutex_lock(&e_comp->ec_list_mutex);
if (!e_client_util_ignored_get(ec))
e_client_frame_update(ec);
- e_comp_object_fullscreen(ec->frame);
+ e_view_client_fullscreen(e_client_view_get(ec));
if (ec->comp_data->shell.configure_send)
_e_desk_area_configure_send(ec, 0, 1);
if (!e_client_util_ignored_get(ec))
e_client_frame_update(ec);
- e_comp_object_unfullscreen(ec->frame);
+ e_view_client_unfullscreen(e_client_view_get(ec));
if (ec->comp_data->shell.configure_send)
_e_desk_area_configure_send(ec, 0, 0);
if (ec->fullscreen)
eda->fullscreen_clients = eina_list_remove(eda->fullscreen_clients, ec);
e_client_comp_hidden_set(ec, 1);
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
e_client_iconify_event_send(ec);
if (ec->internal)
{
ELOGF("EDA", "UNICONIFY|internal object force show. eda:%p", ec, eda);
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
}
if (ec->pixmap)
{
if (cdata && cdata->mapped)
{
- ELOGF("EDA", "UNICONIFY|object show. eda:%p frame_visible:%d",
- ec, eda, evas_object_visible_get(ec->frame));
- evas_object_show(ec->frame);
+ ELOGF("EDA", "UNICONIFY|object show. eda:%p frame_visible:%d(%d)",
+ ec, eda, evas_object_visible_get(ec->frame), e_view_client_visible_get(e_client_view_get(ec)));
+ e_view_client_show(e_client_view_get(ec));
}
else
{
{
if (cdata && cdata->mapped)
{
- ELOGF("EDA", "UNICONIFY|object show. no use buffer flush. eda:%p frame_visible:%d",
- ec, eda, evas_object_visible_get(ec->frame));
- evas_object_show(ec->frame);
+ ELOGF("EDA", "UNICONIFY|object show. no use buffer flush. eda:%p frame_visible:%d(%d)",
+ ec, eda, evas_object_visible_get(ec->frame), e_view_client_visible_get(e_client_view_get(ec)));
+ e_view_client_show(e_client_view_get(ec));
}
}
}
EINA_LIST_FREE(list, child)
{
child->sticky = 1;
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
}
}
}
zh = y2 - yy1;
}
- e_comp_object_maximize(ec->frame);
+ e_view_client_maximize(e_client_view_get(ec));
switch (max & E_MAXIMIZE_DIRECTION)
{
e_client_comp_hidden_set(ec, EINA_TRUE);
}
- evas_object_pass_events_set(ec->frame, EINA_TRUE);
- if (ec->visible) evas_object_hide(ec->frame);
+ e_view_pass_events_set(e_view_client_view_get(e_client_view_get(ec)), true);
+ if (ec->visible) e_view_client_hide(e_client_view_get(ec));
if (!ec->internal) e_object_del(E_OBJECT(ec));
e_comp_wl_focus_check();
*/
w = ec->w, h = ec->h;
- e_comp_object_frame_wh_unadjust(ec->frame, w, h, &pw, &ph);
+ e_view_client_frame_wh_unadjust(e_client_view_get(ec), w, h, &pw, &ph);
- e_comp_object_frame_recalc(ec->frame);
+ e_view_client_frame_recalc(e_client_view_get(ec));
if (!ec->fullscreen)
- e_comp_object_frame_wh_adjust(ec->frame, ec->client.w, ec->client.h, &w, &h);
+ e_view_client_frame_wh_adjust(e_client_view_get(ec), ec->client.w, ec->client.h, &w, &h);
if (ec->fullscreen)
{
- evas_object_resize(ec->frame, eda->w, eda->h);
+ e_view_client_size_set(e_client_view_get(ec), eda->w, eda->h);
}
else if (ec->new_client)
{
if ((ec->w < 1) || (ec->h < 1)) return;
- e_comp_object_frame_wh_adjust(ec->frame, pw, ph, &w, &h);
- evas_object_resize(ec->frame, w, h);
+ e_view_client_frame_wh_adjust(e_client_view_get(ec), pw, ph, &w, &h);
+ e_view_client_size_set(e_client_view_get(ec), w, h);
}
else if ((w != ec->w) || (h != ec->h))
- evas_object_resize(ec->frame, w, h);
+ e_view_client_size_set(e_client_view_get(ec), w, h);
}
static void
E_Desk_Area *eda;
E_Client *ec;
int new_x, new_y;
+ int w, h;
eda_client = wl_container_of(listener, eda_client, client_stay_within_margin);
eda = eda_client->eda;
_e_client_stay_within_canvas_margin(ec, ec->x, ec->y, &new_x, &new_y);
if ((ec->x != new_x) || (ec->y != new_y))
- evas_object_move(ec->frame, new_x, new_y);
+ {
+ e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
+ e_view_client_geometry_set(e_client_view_get(ec), new_x, new_y, w, h);
+ }
}
}
static void
_e_client_move_handle(E_Client *ec)
{
- int x, y;
+ int x, y, w, h;
if ((ec->moveinfo.down.button >= 1) && (ec->moveinfo.down.button <= 3))
{
if (ec->floating)
_e_client_stay_within_canvas_margin(ec, x, y, &x, &y);
- evas_object_move(ec->frame, x, y);
+ e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
+ e_view_client_geometry_set(e_client_view_get(ec), x, y, w, h);
if (e_client_transform_core_enable_get(ec))
{
layer_set:
if (cw->layer == l) return;
- if (e_util_client_layer_map(layer) == 9999)
+ if (e_comp_canvas_client_layer_map(layer) == 9999)
return; //invalid layer for clients not doing comp effects
if (cw->ec->fullscreen)
{
w = ec->mouse.last_down[ec->moveinfo.down.button - 1].w;
h = ec->mouse.last_down[ec->moveinfo.down.button - 1].h;
- if (e_comp_object_frame_exists(ec->frame))
- e_comp_object_frame_wh_unadjust(ec->frame, w, h, &w, &h);
+ if (e_view_client_frame_exists(e_client_view_get(ec)))
+ e_view_client_frame_wh_unadjust(e_client_view_get(ec), w, h, &w, &h);
switch (ec->resize_mode)
{
eda_client = wl_container_of(listener, eda_client, comp_object_color_set);
ec = eda_client->ec;
- evas_object_color_get(ec->frame, NULL, NULL, NULL, &a);
+ e_view_client_color_get(e_client_view_get(ec), NULL, NULL, NULL, &a);
if (ec->netwm.opacity == a) return;
ec->netwm.opacity = a;
{
EINA_LIST_REVERSE_FOREACH_SAFE(eda->ec_lists[i], l, ll, ec)
{
- evas_object_raise(ec->frame);
+ e_view_raise_to_top(e_view_client_view_get(e_client_view_get(ec)));
}
}
}
//EINA_LIST_FOREACH(eda->ec_lists[i], l, ec)
EINA_LIST_FOREACH_SAFE(eda->ec_lists[i], l, ll, ec)
{
- evas_object_lower(ec->frame);
+ e_view_lower_to_bottom(e_view_client_view_get(e_client_view_get(ec)));
}
}
}
EINA_SAFETY_ON_NULL_RETURN_VAL(eda, EINA_FALSE);
- data = evas_object_data_get(ec->frame, DESK_AREA_EC_DATA_KEY);
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), DESK_AREA_EC_DATA_KEY);
if (data == eda) return EINA_TRUE;
return EINA_FALSE;
#include <Ecore.h>
#include <Eina.h>
-//soolim
#define E_DISPLAY
#define CHECKING_PRIMARY_ZPOS
#include "e_pixmap_intern.h"
#include "e_comp_wl_buffer_intern.h"
#include "e_comp_object_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#ifndef EGL_TEXTURE_RGBA
# define EGL_TEXTURE_RGBA 0x305E
return EINA_FALSE;
}
- if (e_comp_object_render_update_lock_get(ec->frame))
+ if (e_view_client_render_update_lock_get(e_client_view_get(ec)))
{
ELOGF("PIXMAP", "Render update locked, cp:%p", NULL, cp);
return EINA_FALSE;
* managed and be pending if previous buffer is not rendered yet. */
/* set size of image object to new buffer size */
e_pixmap_size_get(cp, &bw, &bh);
- e_comp_object_size_update(ec->frame, bw, bh);
+ e_view_client_size_update(e_client_view_get(ec), bw, bh);
}
else if (buffer->type == E_COMP_WL_BUFFER_TYPE_TBM)
{
* managed and be pending if previous buffer is not rendered yet. */
/* set size of image object to new buffer size */
e_pixmap_size_get(cp, &bw, &bh);
- e_comp_object_size_update(ec->frame, bw, bh);
+ e_view_client_size_update(e_client_view_get(ec), bw, bh);
/* buffer has no client resources */
return EINA_TRUE;
e_view_position_set(&edje->view, x, y);
}
+static void
+_e_view_edje_util_show(void *data EINA_UNUSED, Evas_Object *obj)
+{
+ Eina_Bool ref = EINA_TRUE;
+ if (evas_object_visible_get(obj))
+ {
+ void *d;
+
+ d = evas_object_data_del(obj, "comp_hiding");
+ if (d)
+ /* currently trying to hide */
+ ref = EINA_FALSE;
+ else
+ /* already visible */
+ return;
+ }
+
+ evas_object_show(obj);
+ if (ref)
+ {
+ evas_object_ref(obj);
+ evas_object_data_set(obj, "comp_ref", (void*)1);
+ }
+ edje_object_signal_emit(obj, "e,state,visible", "e");
+ evas_object_data_set(obj, "comp_showing", (void*)1);
+ if (e_comp_util_object_is_above_nocomp(obj))
+ {
+ evas_object_data_set(obj, "comp_override", (void*)1);
+ e_comp_override_add();
+ }
+}
+
+static void
+_e_view_edje_util_hide(void *data EINA_UNUSED, Evas_Object *obj)
+{
+ if (!evas_object_visible_get(obj)) return;
+ /* already hiding */
+ if (evas_object_data_get(obj, "comp_hiding")) return;
+ if (!evas_object_data_del(obj, "comp_showing"))
+ {
+ evas_object_ref(obj);
+ evas_object_data_set(obj, "comp_ref", (void*)1);
+ }
+ edje_object_signal_emit(obj, "e,state,hidden", "e");
+ evas_object_data_set(obj, "comp_hiding", (void*)1);
+
+ if (evas_object_data_del(obj, "comp_override"))
+ e_comp_override_timed_pop();
+}
+
+static void
+_e_view_edje_util_done_defer(void *data, E_View_Edje *edje, const char *emission, const char *source)
+{
+ E_View *edje_view;
+
+ EINA_SAFETY_ON_NULL_RETURN(edje);
+
+ edje_view = e_view_edje_view_get(edje);
+ if (!e_util_strcmp(emission, "e,action,hide,done"))
+ {
+ if (!e_view_data_del(edje_view, "comp_hiding")) return;
+
+ evas_object_intercept_hide_callback_del(edje_view->eo, _e_view_edje_util_hide);
+ e_view_hide(edje_view);
+ evas_object_intercept_hide_callback_add(edje_view->eo, _e_view_edje_util_hide, data);
+ }
+ else
+ e_view_data_del(edje_view, "comp_showing");
+ if (e_view_data_del(edje_view, "comp_ref"))
+ evas_object_unref(edje_view->eo);
+}
+
+static void
+_e_view_edje_util_del(struct wl_listener *listener, void *data)
+{
+ E_View_Edje *edje;
+ E_View *edje_view;
+ Eina_List *l;
+ Eina_Bool comp_object;
+
+ edje = wl_container_of(listener, edje, destroy);
+ edje_view = e_view_edje_view_get(edje);
+
+ comp_object = !!e_view_data_get(edje_view, "comp_object");
+ if (comp_object)
+ {
+ E_View *view;
+
+ view = e_view_edje_part_swallow_get(edje, "e.swallow.content");
+ if (view)
+ {
+ e_view_edje_part_unswallow(edje, view);
+ e_view_destroy(view);
+ }
+
+ e_comp_render_queue();
+ }
+ l = e_view_data_get(edje_view, "comp_object-to_del");
+ E_FREE_LIST(l, evas_object_del);
+}
+
+static void
+_e_view_edje_util_restack(struct wl_listener *listener, void *data)
+{
+ E_View_Edje *edje;
+ E_View *edje_view;
+
+ edje = wl_container_of(listener, edje, restack);
+ edje_view = e_view_edje_view_get(edje);
+
+ if (e_comp_util_object_is_above_nocomp(edje_view->eo) &&
+ (!e_view_data_get(edje_view, "comp_override")))
+ {
+ e_view_data_set(edje_view, "comp_override", (void*)1);
+ e_comp_override_add();
+ }
+}
+
+static void
+_e_view_edje_event_free(void *d EINA_UNUSED, void *event)
+{
+ E_Event_Comp_Object *ev = event;
+ E_Client *ec;
+
+ ec = evas_object_data_get(ev->comp_object, "E_Client");
+ if (ec)
+ {
+ UNREFD(ec, 1);
+ e_object_unref(E_OBJECT(ec));
+ }
+ evas_object_unref(ev->comp_object);
+ free(ev);
+}
+
+static void
+_e_view_edje_event_add(E_View_Edje *edje)
+{
+ E_Event_Comp_Object *ev;
+ E_View *edje_view;
+ E_Client *ec;
+
+ if (stopping) return;
+ ev = E_NEW(E_Event_Comp_Object, 1);
+ EINA_SAFETY_ON_NULL_RETURN(ev);
+
+ edje_view = e_view_edje_view_get(edje);
+ evas_object_ref(edje_view->eo);
+ ec = e_view_data_get(edje_view, "E_Client");
+ if (ec)
+ {
+ REFD(ec, 1);
+ e_object_ref(E_OBJECT(ec));
+ }
+ ecore_event_add(E_EVENT_COMP_OBJECT_ADD, ev, _e_view_edje_event_free, NULL);
+}
+
+
E_API E_View_Edje *
e_view_edje_util_add(E_View *view)
{
- return NULL;
+ E_View_Edje *edje;
+ E_View *edje_view;
+ const char *name;
+ E_Comp_Config *conf = e_comp_config_get();
+ Eina_Bool skip = EINA_FALSE;
+ char buf[1024];
+ int ok = 0;
+ int x, y, w, h;
+ Eina_Bool vis;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(view, NULL);
+
+ name = e_view_name_get(view);
+ vis = e_view_visible_get(view);
+ edje = e_view_edje_create(e_view_parent_get(view));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(edje, NULL);
+
+ edje_view = e_view_edje_view_get(edje);
+ e_view_data_set(edje_view, "comp_object", (void*)1);
+ if (name)
+ skip = (!strncmp(name, "noshadow", 8));
+ if (skip)
+ e_view_data_set(edje_view, "comp_object_skip", (void*)1);
+
+ if (conf->shadow_style)
+ {
+ snprintf(buf, sizeof(buf), "e/comp/frame/%s", conf->shadow_style);
+ ok = e_theme_edje_view_set(edje, NULL, buf);
+ }
+ if (!ok)
+ e_theme_edje_view_set(edje, NULL, "e/comp/frame/default");
+ if ((view->type == E_VIEW_TYPE_EDJE) || (!e_view_edje_data_get(edje, "noshadow")))
+ e_view_edje_signal_emit(edje, "e,state,shadow,on", "e");
+ else
+ e_view_edje_signal_emit(edje, "e,state,shadow,off", "e");
+
+ if (view->type == E_VIEW_TYPE_CLIENT)
+ e_view_client_geometry_get((E_View_Client *)view, &x, &y, &w, &h);
+ else if (view->type == E_VIEW_TYPE_EDJE)
+ e_view_edje_geometry_get((E_View_Edje *)view, &x, &y, &w, &h);
+ else
+ {
+ e_view_position_get(view, &x, &y);
+ if (view->type == E_VIEW_TYPE_RECT)
+ e_view_rect_size_get((E_View_Rect *)view, &w, &h);
+ else //E_VIEW_TYPE_IMAGE
+ e_view_image_size_get((E_View_Image *)view, &w, &h);
+ }
+
+ e_view_edje_geometry_set(edje, x, y, w, h);
+ e_view_pass_events_set(edje_view, e_view_pass_events_get(view));
+
+ e_view_edje_signal_callback_add(edje, "e,action,*,done", "e", _e_view_edje_util_done_defer, NULL);
+
+ evas_object_intercept_show_callback_add(edje_view->eo, _e_view_edje_util_show, NULL);
+ evas_object_intercept_hide_callback_add(edje_view->eo, _e_view_edje_util_hide, NULL);
+
+ edje->destroy.notify = _e_view_edje_util_del;
+ e_view_event_listener_add(edje_view, E_VIEW_DESTROY, &edje->destroy);
+
+ edje->restack.notify = _e_view_edje_util_restack;
+ e_view_event_listener_add(edje_view, E_VIEW_RESTACK, &edje->restack);
+
+ e_view_edje_signal_emit(edje, "e,state,hidden", "e");
+
+ e_view_edje_part_swallow(edje, "e.swallow.content", view);
+
+ _e_view_edje_event_add(edje);
+
+ if (vis)
+ e_view_show(edje_view);
+
+ return edje;
}
E_API bool
#include "e_comp_canvas_intern.h"
#include "e_comp_input_intern.h"
#include "e_input_thread_client_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#define ZONE_EC_DATA_KEY "E_Zone_Client"
else
new_y = zy;
- e_comp_object_frame_geometry_get(ec->frame, NULL, NULL, &t, NULL);
+ e_view_client_frame_geometry_get(e_client_view_get(ec), NULL, NULL, &t, NULL);
parent_ec = ec->parent;
if (parent_ec)
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 (ec->x) e_view_client_frame_xy_adjust(e_client_view_get(ec), ec->x, 0, &ec->x, NULL);
+ if (ec->y) e_view_client_frame_xy_adjust(e_client_view_get(ec), 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;
{
E_Zone *data;
- data = evas_object_data_get(ec->frame, ZONE_EC_DATA_KEY);
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), ZONE_EC_DATA_KEY);
if (data)
{
if (data == zone)
return;
}
- evas_object_data_del(ec->frame, ZONE_EC_DATA_KEY);
+ e_view_data_del(e_view_client_view_get(e_client_view_get(ec)), ZONE_EC_DATA_KEY);
}
- evas_object_data_set(ec->frame, ZONE_EC_DATA_KEY, zone);
+ e_view_data_set(e_view_client_view_get(e_client_view_get(ec)), ZONE_EC_DATA_KEY, zone);
}
static void
if (!e_zone_has_ec(zone, ec)) continue;
if ((dx != 0) || (dy != 0))
- evas_object_move(ec->frame, ec->x + dx, ec->y + dy);
+ e_view_position_set(e_view_client_view_get(e_client_view_get(ec)), ec->x + dx, ec->y + dy);
// we shrank the zone - adjust windows more
if ((dw < 0) || (dh < 0))
{
evas_object_del(zone->bg_event_object);
evas_object_del(zone->bg_clip_object);
- evas_object_del(zone->base);
- evas_object_del(zone->over);
+ e_view_destroy(zone->base);
+ e_view_destroy(zone->over);
/* free desks */
for (x = 0; x < zone->desk_x_count; x++)
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);
+ e_view_position_set(e_view_client_view_get(e_client_view_get(ec)), x, y);
}
ec->zone = zone; // FIXME: This line must be deleted.
EINA_SAFETY_ON_NULL_RETURN_VAL(zone, EINA_FALSE);
- data = evas_object_data_get(ec->frame, ZONE_EC_DATA_KEY);
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), ZONE_EC_DATA_KEY);
if (data == zone) return EINA_TRUE;
return EINA_FALSE;
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;
- if (!ec->frame) continue;
+ if (!e_client_view_get(ec)) continue;
if (ec->visibility.skip) continue;
if (ec->is_cursor) continue;
cdata = e_client_cdata_get(ec);
if (!e_config->calc_vis_without_effect)
{
- if ((e_comp_object_is_animating(ec->frame)) ||
- (evas_object_data_get(ec->frame, "effect_running")))
+ if ((e_view_client_is_animating(e_client_view_get(ec))) ||
+ (e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), "effect_running")))
{
effect_running = EINA_TRUE;
if (ec->launching)
ec_vis = ec_opaque = skip_rot_pending_show = is_vis_on_skip = EINA_FALSE;
skip_by_pending_show = 0;
calc_region = EINA_TRUE;
- ec_frame_visible = evas_object_visible_get(ec->frame);
+ ec_frame_visible = e_view_client_visible_get(e_client_view_get(ec));
iconified_by_client = e_client_is_iconified_by_client(ec);
if (!ec->visible)
#include "e_alpha_mask_rect_intern.h"
#include "e_display_intern.h"
#include "e_video_shell_intern.h"
+#include "e_view.h"
#include <tbm_bufmgr.h>
#include <tbm_surface.h>
int x = 0, y = 0, w = 0, h = 0;
unsigned int transform = 0, visible = 0, alpha = 0, ignore = 0, maskobj = 0, video = 0, stand = 0;
E_Alpha_Mask_Rect *mask_rect;
- Ecore_Window mask_rect_object = 0;
+ Ecore_Window mask_rect_view = 0;
const char *name = NULL;
E_Comp_Wl_Buffer *buffer;
E_Map *map;
ignore = e_client_util_ignored_get(ec);
mask_rect = e_alpha_mask_rect_try_from_ec(ec);
if (mask_rect)
- mask_rect_object = (Ecore_Window)e_alpha_mask_rect_evas_object_get(mask_rect);
+ mask_rect_view = (Ecore_Window)e_alpha_mask_rect_view_get(mask_rect);
maskobj = e_comp_object_mask_has(ec->frame);
video = (ec->comp_data->video_client || e_client_video_hw_composition_check(ec)) ? 1 : 0;
name = e_client_util_name_get(ec);
eldbus_message_iter_arguments_append
(struct_of_ec, SIGNATURE_SUBSURFACE,
- win, parent, buf_id, x, y, w, h, transform, visible, alpha, ignore, maskobj, video, stand, mask_rect_object, name);
+ win, parent, buf_id, x, y, w, h, transform, visible, alpha, ignore, maskobj, video, stand, mask_rect_view, name);
eldbus_message_iter_container_close(array_of_ec, struct_of_ec);
}
return reply;
}
- evas_object_color_get(e_comp->bg_blank_object, &pa, &pr, &pg, &pb);
- evas_object_color_set(e_comp->bg_blank_object, r, g, b, a);
+ e_view_color_get(e_comp->bg_blank_view, &pa, &pr, &pg, &pb);
+ e_view_color_set(e_comp->bg_blank_view, r, g, b, a);
- INF("The background color of bg_blank_object has been changed.");
+ INF("The background color of bg_blank_view has been changed.");
INF("(A, R, G, B) : %d, %d, %d, %d -> %d, %d, %d, %d", pa, pr, pg, pb, a, r, g, b);
return reply;
#include "e_error_intern.h"
#include "e_hwc_window_queue_intern.h"
#include "e_display_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <Evas_GL.h>
#include <gbm.h>
EINTERN Eina_Bool
e_hwc_client_is_above_hwc(E_Client *ec, E_Client *hwc_ec)
{
- Evas_Object *o;
- int layer, hwc_layer;
+ E_View *view, *view_hwc, *view_tmp;
+ E_Canvas_Layer layer, layer_hwc;
EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(hwc_ec, EINA_FALSE);
if (ec == hwc_ec) return EINA_FALSE;
- if (!evas_object_visible_get(ec->frame)) return EINA_FALSE;
+ if (!e_view_client_visible_get(e_client_view_get(ec))) return EINA_FALSE;
- layer = evas_object_layer_get(ec->frame);
- hwc_layer = evas_object_layer_get(hwc_ec->frame);
+ view = e_view_client_view_get(e_client_view_get(ec));
+ view_hwc = e_view_client_view_get(e_client_view_get(hwc_ec));
+
+ layer = e_canvas_layer_find(e_comp->canvas, view);
+ layer_hwc = e_canvas_layer_find(e_comp->canvas, view_hwc);
/* compare layer */
- if (hwc_layer > layer) return EINA_FALSE;
- if (layer > hwc_layer) return EINA_TRUE;
+ if (layer_hwc > layer) return EINA_FALSE;
+ if (layer > layer_hwc) return EINA_TRUE;
- o = evas_object_above_get(hwc_ec->frame);
- if (evas_object_layer_get(o) == hwc_layer)
+ view_tmp = e_view_above_get(view);
+ if (e_canvas_layer_find(e_comp->canvas, view_tmp) == layer_hwc)
{
- do {
- if (o == ec->frame)
- return EINA_TRUE;
- o = evas_object_above_get(o);
- } while (o && (evas_object_layer_get(o) == hwc_layer));
+ do
+ {
+ if (view_tmp == view)
+ return EINA_TRUE;
+ view_tmp = e_view_above_get(view_tmp);
+ }
+ while (view_tmp && (e_canvas_layer_find(e_comp->canvas, view_tmp) == layer_hwc));
}
else
return EINA_TRUE;
#include "e_hwc_intern.h"
#include "e_policy_private_data.h"
#include "e_client_intern.h"
-#include "e_comp_object_intern.h"
#include "e_utils_intern.h"
+#include "e_comp_canvas.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <wayland-tbm-server.h>
if (ec->comp_override > 0) return EINA_FALSE;
- if (e_comp_object_is_animating(ec->frame)) return EINA_FALSE;
+ if (e_view_client_is_animating(e_client_view_get(ec))) return EINA_FALSE;
if ((!cdata) ||
(!cdata->buffer_ref.buffer) ||
return EINA_FALSE;
}
- if (e_comp_object_image_filter_get(ec->frame) != E_COMP_IMAGE_FILTER_NONE)
+ if (e_view_client_image_filter_get(e_client_view_get(ec)) != E_COMP_IMAGE_FILTER_NONE)
return EINA_FALSE;
return EINA_TRUE;
int n_vis = 0, n_ec = 0, n_cur = 0, n_skip = 0;
Eina_List *hwc_ok_clist = NULL, *vis_clist = NULL;
E_Output *output = hwc->output;
+ E_View *view;
_e_hwc_planes_prepare_init(hwc);
// check clients not able to use hwc
EINA_LIST_FOREACH(vis_clist, vl, ec)
{
+ view = e_view_client_view_get(e_client_view_get(ec));
// if there is a ec which is lower than quickpanel and quickpanel is opened.
- if (E_POLICY_QUICKPANEL_LAYER >= evas_object_layer_get(ec->frame))
+ if (E_CANVAS_LAYER_CLIENT_ALERT >= e_canvas_layer_find(e_comp_canvas_get(), view))
{
// check whether quickpanel is open than break
if (e_qps_visible_get()) goto done;
}
// if ec->frame is not for client buffer (e.g. launchscreen)
- if (e_comp_object_content_type_get(ec->frame) != E_COMP_OBJECT_CONTENT_TYPE_INT_IMAGE)
+ if (e_view_client_content_type_get(e_client_view_get(ec)) != E_COMP_OBJECT_CONTENT_TYPE_INT_IMAGE)
goto done;
// if there is UI subfrace, it means need to composite
return EINA_FALSE;
}
- e_comp_object_hwc_update_set(ec->frame, EINA_TRUE);
+ e_view_client_hwc_update_set(e_client_view_get(ec), EINA_TRUE);
}
else
{
#include "e_policy_visibility_intern.h"
#include "e_client_video_intern.h"
#include "e_client_intern.h"
-#include "e_comp_object_intern.h"
#include "e_utils_intern.h"
#include "e_blur_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <pixman.h>
#include <wayland-tbm-server.h>
}
static void
-_e_hwc_window_obj_cb_show(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_view_cb_show(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, show_listener);
+ if (!hwc_window) return;
hwc_window->evas_visible = EINA_TRUE;
}
static void
-_e_hwc_window_obj_cb_hide(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_view_cb_hide(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, hide_listener);
+ if (!hwc_window) return;
hwc_window->evas_visible = EINA_FALSE;
}
static void
-_e_hwc_window_obj_cb_move(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_view_cb_move(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, move_listener);
+ if (!hwc_window) return;
e_hwc_window_changed_set(hwc_window, E_HWC_WINS_CHANGED_WIN_GEOMETRY);
}
static void
-_e_hwc_window_obj_cb_resize(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_view_cb_resize(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, resize_listener);
+ if (!hwc_window) return;
e_hwc_window_changed_set(hwc_window, E_HWC_WINS_CHANGED_WIN_GEOMETRY);
}
static void
-_e_hwc_window_obj_cb_restack(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_view_cb_restack(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, restack_listener);
+ if (!hwc_window) return;
e_hwc_window_changed_set(hwc_window, E_HWC_WINS_CHANGED_WIN_VISIBLE);
}
ec = hwc_window->ec;
EINA_SAFETY_ON_NULL_RETURN(ec);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_SHOW,
- _e_hwc_window_obj_cb_show,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_HIDE,
- _e_hwc_window_obj_cb_hide,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_MOVE,
- _e_hwc_window_obj_cb_move,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_hwc_window_obj_cb_resize,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_RESTACK,
- _e_hwc_window_obj_cb_restack,
- hwc_window);
+ wl_list_remove(&hwc_window->show_listener.link);
+ wl_list_remove(&hwc_window->hide_listener.link);
+ wl_list_remove(&hwc_window->move_listener.link);
+ wl_list_remove(&hwc_window->resize_listener.link);
+ wl_list_remove(&hwc_window->restack_listener.link);
ec->hwc_window = NULL;
hwc_window->ec = NULL;
hwc_window = container_of(listener, E_Hwc_Window, image_filter_set_listener);
if (!hwc_window->ec) return;
- if (e_comp_object_image_filter_get(hwc_window->ec->frame) != E_COMP_IMAGE_FILTER_NONE)
+ if (e_view_client_image_filter_get(e_client_view_get(hwc_window->ec)) != E_COMP_IMAGE_FILTER_NONE)
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
hwc_window = container_of(listener, E_Hwc_Window, render_op_set_listener);
if (!hwc_window->ec) return;
- if (e_comp_object_render_op_get(hwc_window->ec->frame) != EVAS_RENDER_BLEND)
+ if (e_view_client_render_op_get(e_client_view_get(hwc_window->ec)) != E_VIEW_RENDER_BLEND)
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
hwc_window = container_of(listener, E_Hwc_Window, content_type_set_listener);
if (!hwc_window->ec) return;
- if (e_comp_object_content_type_get(hwc_window->ec->frame) != E_COMP_OBJECT_CONTENT_TYPE_INT_IMAGE)
+ if (e_view_client_content_type_get(e_client_view_get(hwc_window->ec)) != E_COMP_OBJECT_CONTENT_TYPE_INT_IMAGE)
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE);
hwc_window = container_of(listener, E_Hwc_Window, color_set_listener);
if (!hwc_window->ec) return;
- e_comp_object_color_get(hwc_window->ec->frame, NULL, NULL, NULL, &alpha);
+ e_view_client_color_get(e_client_view_get(hwc_window->ec), NULL, NULL, NULL, &alpha);
- if ((alpha != 255) && e_comp_object_redirected_get(hwc_window->ec->frame))
+ if ((alpha != 255) && e_view_client_redirected_get(e_client_view_get(hwc_window->ec)))
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
if (!hwc_window->ec) return;
- if (e_comp_object_image_filter_get(hwc_window->ec->frame) != E_COMP_IMAGE_FILTER_NONE)
+ if (e_view_client_image_filter_get(e_client_view_get(hwc_window->ec)) != E_COMP_IMAGE_FILTER_NONE)
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
- if (e_comp_object_render_op_get(hwc_window->ec->frame) != EVAS_RENDER_BLEND)
+ if (e_view_client_render_op_get(e_client_view_get(hwc_window->ec)) != E_VIEW_RENDER_BLEND)
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
- e_comp_object_color_get(hwc_window->ec->frame, NULL, NULL, NULL, &alpha);
+ e_view_client_color_get(e_client_view_get(hwc_window->ec), NULL, NULL, NULL, &alpha);
- if ((alpha != 255) && e_comp_object_redirected_get(hwc_window->ec->frame))
+ if ((alpha != 255) && e_view_client_redirected_get(e_client_view_get(hwc_window->ec)))
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
- if (e_comp_object_render_update_lock_get(hwc_window->ec->frame))
+ if (e_view_client_render_update_lock_get(e_client_view_get(hwc_window->ec)))
e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK);
else
e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK);
_e_hwc_window_new(E_Hwc *hwc, E_Client *ec, E_Hwc_Window_State state)
{
E_Hwc_Window *hwc_window;
+ E_View *view;
tdm_hwc *thwc;;
tdm_error error;
e_hwc_presentation_callback_list_init(&hwc_window->presentation_callbacks);
hwc_window->image_filter_set_listener.notify = _e_hwc_window_cb_image_filter_set;
- e_comp_object_image_filter_set_listener_add(ec->frame, &hwc_window->image_filter_set_listener);
+ e_view_client_image_filter_set_listener_add(e_client_view_get(ec), &hwc_window->image_filter_set_listener);
hwc_window->render_op_set_listener.notify = _e_hwc_window_cb_render_op_set;
- e_comp_object_render_op_set_listener_add(ec->frame, &hwc_window->render_op_set_listener);
+ e_view_client_render_op_set_listener_add(e_client_view_get(ec), &hwc_window->render_op_set_listener);
hwc_window->content_type_set_listener.notify = _e_hwc_window_cb_content_type_set;
- e_comp_object_content_type_set_listener_add(ec->frame, &hwc_window->content_type_set_listener);
+ e_view_client_content_type_set_listener_add(e_client_view_get(ec), &hwc_window->content_type_set_listener);
hwc_window->color_set_listener.notify = _e_hwc_window_cb_color_set;
- e_comp_object_color_set_listener_add(ec->frame, &hwc_window->color_set_listener);
+ e_view_client_color_set_listener_add(e_client_view_get(ec), &hwc_window->color_set_listener);
hwc_window->color_visible_set_listener.notify = _e_hwc_window_cb_color_visible_set;
- e_comp_object_color_visible_set_listener_add(ec->frame, &hwc_window->color_visible_set_listener);
-
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_SHOW,
- _e_hwc_window_obj_cb_show,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_HIDE,
- _e_hwc_window_obj_cb_hide,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_MOVE,
- _e_hwc_window_obj_cb_move,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_hwc_window_obj_cb_resize,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_RESTACK,
- _e_hwc_window_obj_cb_restack,
- hwc_window);
-
- if (evas_object_visible_get(ec->frame))
+ e_view_client_color_visible_set_listener_add(e_client_view_get(ec), &hwc_window->color_visible_set_listener);
+
+ view = e_view_client_view_get(e_client_view_get(ec));
+ hwc_window->show_listener.notify = _e_hwc_window_view_cb_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &hwc_window->show_listener);
+ hwc_window->hide_listener.notify = _e_hwc_window_view_cb_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &hwc_window->hide_listener);
+ hwc_window->move_listener.notify = _e_hwc_window_view_cb_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &hwc_window->move_listener);
+ hwc_window->resize_listener.notify = _e_hwc_window_view_cb_resize;
+ e_view_event_listener_add(view, E_VIEW_RESIZE, &hwc_window->resize_listener);
+ hwc_window->restack_listener.notify = _e_hwc_window_view_cb_restack;
+ e_view_event_listener_add(view, E_VIEW_RESTACK, &hwc_window->restack_listener);
+
+ if (e_view_client_visible_get(e_client_view_get(ec)))
e_hwc_window_changed_set(hwc_window, E_HWC_WINS_CHANGED_WIN_VISIBLE);
EHWINF("is created on eout:%p, video:%d cursor:%d",
comp_wl_buffer = _e_hwc_window_comp_wl_buffer_get(hwc_window);
if ((!comp_wl_buffer) &&
- (!evas_object_visible_get(ec->frame)) &&
+ (!e_view_client_visible_get(e_client_view_get(ec))) &&
(ec->exp_iconify.buffer_flush) &&
(e_policy_visibility_client_is_iconic(ec)))
return EINA_FALSE;
if (hwc_window->ec->redirected)
{
- e_comp_object_redirected_set(ec->frame, EINA_TRUE);
+ e_view_client_redirected_set(e_client_view_get(ec), true);
e_pixmap_image_refresh(ec->pixmap);
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
if (!ret)
- e_comp_object_render_update_del(ec->frame);
+ e_view_client_render_update_del(e_client_view_get(ec));
e_hwc_windows_present_sync(hwc_window->hwc);
{
if (hwc_window->ec->redirected)
{
- e_comp_object_redirected_set(ec->frame, EINA_FALSE);
+ e_view_client_redirected_set(e_client_view_get(ec), false);
e_hwc_windows_present_sync(hwc_window->hwc);
E_Map *map = NULL, *new_map = NULL;
int w, h;
Eina_Bool enable;
+ E_View *view;
- EINA_SAFETY_ON_NULL_RETURN(hwc_window->below_transparent_obj);
+ EINA_SAFETY_ON_NULL_RETURN(hwc_window->below_transparent_view);
- evas_object_geometry_get(hwc_window->below_transparent_obj, NULL, NULL, &w, &h);
+ e_view_rect_size_get(hwc_window->below_transparent_view, &w, &h);
+ view = e_view_rect_view_get(hwc_window->below_transparent_view);
enable = e_client_transform_core_enable_get(hwc_window->ec);
if (enable)
- map = e_comp_object_map_get(hwc_window->ec->frame);
+ map = e_view_client_map_get(e_client_view_get(hwc_window->ec));
if ((enable) && (map))
{
return;
}
- e_map_util_points_populate_from_object_full(new_map, hwc_window->ec->frame, 0);
+ e_map_util_points_populate_from_view_full(new_map, view, 0);
e_map_util_points_color_set(new_map, 255, 255, 255, 255);
}
e_map_point_image_uv_set(new_map, 2, w, h);
e_map_point_image_uv_set(new_map, 3, 0, h);
- e_comp_object_map_set(hwc_window->below_transparent_obj, new_map);
- e_comp_object_map_enable_set(hwc_window->below_transparent_obj, EINA_TRUE);
+ e_view_map_set(view, new_map);
+ e_view_map_enable_set(view, true);
if (map) e_map_free(map);
}
static void
-_e_hwc_window_below_transparent_obj_cb_show(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_below_transparent_view_cb_show(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
+ E_View *view;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, transparent_show_listener);
+ if (!hwc_window) return;
- evas_object_show(hwc_window->below_transparent_obj);
+ view = e_view_rect_view_get(hwc_window->below_transparent_view);
+ e_view_show(view);
}
static void
-_e_hwc_window_below_transparent_obj_cb_hide(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_below_transparent_view_cb_hide(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
+ E_View *view;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, transparent_hide_listener);
+ if (!hwc_window) return;
- evas_object_hide(hwc_window->below_transparent_obj);
+ view = e_view_rect_view_get(hwc_window->below_transparent_view);
+ e_view_hide(view);
}
static void
-_e_hwc_window_below_transparent_obj_cb_move(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_below_transparent_view_cb_move(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
+ E_View *view;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, transparent_move_listener);
+ if (!hwc_window) return;
- evas_object_move(hwc_window->below_transparent_obj, hwc_window->ec->x, hwc_window->ec->y);
+ view = e_view_rect_view_get(hwc_window->below_transparent_view);
+ e_view_position_set(view, hwc_window->ec->x, hwc_window->ec->y);
_e_hwc_window_below_transparent_obj_map_apply(hwc_window);
}
static void
-_e_hwc_window_below_transparent_obj_cb_resize(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_below_transparent_view_cb_resize(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, transparent_resize_listener);
+ if (!hwc_window) return;
_e_hwc_window_below_transparent_obj_map_apply(hwc_window);
}
static void
-_e_hwc_window_below_transparent_obj_cb_restack(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_hwc_window_below_transparent_view_cb_restack(struct wl_listener *listener, void *data)
{
E_Hwc_Window *hwc_window;
+ E_View *view, *ec_view;
- if (!(hwc_window = data)) return;
+ hwc_window = wl_container_of(listener, hwc_window, transparent_restack_listener);
+ if (!hwc_window) return;
- evas_object_layer_set(hwc_window->below_transparent_obj, evas_object_layer_get(hwc_window->ec->frame));
- evas_object_stack_below(hwc_window->below_transparent_obj, hwc_window->ec->frame);
+ view = e_view_rect_view_get(hwc_window->below_transparent_view);
+ ec_view = e_view_client_view_get(e_client_view_get(hwc_window->ec));
+ e_view_reparent(view, e_view_parent_get(ec_view));
+ e_view_place_below(view, ec_view);
}
EINTERN void
e_hwc_window_below_transparent_obj_set(E_Hwc_Window *hwc_window, Eina_Bool set)
{
- Evas_Object *below_transparent_obj;
+ E_View_Rect *below_transparent_view;
+ const int color[4] = {0, 0, 0, 0};
+ E_View *view, *ec_view;
EINA_SAFETY_ON_NULL_RETURN(hwc_window);
{
EINA_SAFETY_ON_NULL_RETURN(hwc_window->ec);
- if (hwc_window->below_transparent_obj) return;
+ if (hwc_window->below_transparent_view) return;
- below_transparent_obj = evas_object_rectangle_add(e_comp->evas);
- EINA_SAFETY_ON_NULL_RETURN(below_transparent_obj);
+ ec_view = e_view_client_view_get(e_client_view_get(hwc_window->ec));
+ below_transparent_view = e_view_rect_create(e_view_parent_get(ec_view), 1, 1, color);
+ EINA_SAFETY_ON_NULL_RETURN(below_transparent_view);
- evas_object_pass_events_set(below_transparent_obj, EINA_TRUE);
+ view = e_view_rect_view_get(below_transparent_view);
- evas_object_layer_set(below_transparent_obj, evas_object_layer_get(hwc_window->ec->frame));
- evas_object_stack_below(below_transparent_obj, hwc_window->ec->frame);
- evas_object_render_op_set(below_transparent_obj, EVAS_RENDER_COPY);
+ e_view_pass_events_set(view, true);
+ e_view_place_below(view, ec_view);
+ e_view_render_op_set(view, E_VIEW_RENDER_COPY);
- evas_object_color_set(below_transparent_obj, 0, 0, 0, 0);
- evas_object_move(below_transparent_obj, hwc_window->ec->x, hwc_window->ec->y);
- evas_object_resize(below_transparent_obj, 1, 1);
- evas_object_name_set(below_transparent_obj, "hwc_below_transparent_obj");
+ e_view_position_set(view, hwc_window->ec->x, hwc_window->ec->y);
+ e_view_name_set(view, "hwc_below_transparent_obj");
- hwc_window->below_transparent_obj = below_transparent_obj;
+ hwc_window->below_transparent_view = below_transparent_view;
_e_hwc_window_below_transparent_obj_map_apply(hwc_window);
- if (evas_object_visible_get(hwc_window->ec->frame))
- evas_object_show(hwc_window->below_transparent_obj);
-
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_SHOW,
- _e_hwc_window_below_transparent_obj_cb_show,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_HIDE,
- _e_hwc_window_below_transparent_obj_cb_hide,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_MOVE,
- _e_hwc_window_below_transparent_obj_cb_move,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_hwc_window_below_transparent_obj_cb_resize,
- hwc_window);
- evas_object_event_callback_add(hwc_window->ec->frame, EVAS_CALLBACK_RESTACK,
- _e_hwc_window_below_transparent_obj_cb_restack,
- hwc_window);
+ if (e_view_visible_get(ec_view))
+ e_view_show(view);
+
+ hwc_window->transparent_show_listener.notify = _e_hwc_window_below_transparent_view_cb_show;
+ e_view_event_listener_add(ec_view, E_VIEW_SHOW, &hwc_window->transparent_show_listener);
+ hwc_window->transparent_hide_listener.notify = _e_hwc_window_below_transparent_view_cb_hide;
+ e_view_event_listener_add(ec_view, E_VIEW_HIDE, &hwc_window->transparent_hide_listener);
+ hwc_window->transparent_move_listener.notify = _e_hwc_window_below_transparent_view_cb_move;
+ e_view_event_listener_add(ec_view, E_VIEW_MOVE, &hwc_window->transparent_move_listener);
+ hwc_window->transparent_resize_listener.notify = _e_hwc_window_below_transparent_view_cb_resize;
+ e_view_event_listener_add(ec_view, E_VIEW_RESIZE, &hwc_window->transparent_resize_listener);
+ hwc_window->transparent_restack_listener.notify = _e_hwc_window_below_transparent_view_cb_restack;
+ e_view_event_listener_add(ec_view, E_VIEW_RESTACK, &hwc_window->transparent_restack_listener);
EHWINF("Set below_transparent_obj", hwc_window->ec, hwc_window->hwc, hwc_window);
}
else
{
- if (!hwc_window->below_transparent_obj) return;
+ if (!hwc_window->below_transparent_view) return;
- E_FREE_FUNC(hwc_window->below_transparent_obj, evas_object_del);
+ view = e_view_rect_view_get(hwc_window->below_transparent_view);
+ e_view_destroy(view);
+ hwc_window->below_transparent_view = NULL;
if (hwc_window->ec)
{
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_SHOW,
- _e_hwc_window_below_transparent_obj_cb_show,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_HIDE,
- _e_hwc_window_below_transparent_obj_cb_hide,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_MOVE,
- _e_hwc_window_below_transparent_obj_cb_move,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_hwc_window_below_transparent_obj_cb_resize,
- hwc_window);
- evas_object_event_callback_del_full(hwc_window->ec->frame, EVAS_CALLBACK_RESTACK,
- _e_hwc_window_below_transparent_obj_cb_restack,
- hwc_window);
+ wl_list_remove(&hwc_window->transparent_show_listener.link);
+ wl_list_remove(&hwc_window->transparent_hide_listener.link);
+ wl_list_remove(&hwc_window->transparent_move_listener.link);
+ wl_list_remove(&hwc_window->transparent_resize_listener.link);
+ wl_list_remove(&hwc_window->transparent_restack_listener.link);
}
EHWINF("Unset below_transparent_obj", hwc_window->ec, hwc_window->hwc, hwc_window);
int ee_w, ee_h;
int x1, x2, y1, y2;
E_Map *map;
+ E_View *view;
EINA_SAFETY_ON_NULL_RETURN_VAL(hwc_window, EINA_FALSE);
ecore_evas_geometry_get(e_comp->ee, NULL, NULL, &ee_w, &ee_h);
e_client_geometry_get(ec, &x, &y, &w, &h);
- if ((ec->is_cursor) && (evas_object_map_enable_get(ec->frame)))
+ view = e_view_client_view_get(e_client_view_get(ec));
+ if ((ec->is_cursor) && (e_view_map_enable_get(view)))
{
map = e_client_map_get(ec);
if (map)
#include "e_hwc_intern.h"
#include "e_policy_visibility_intern.h"
#include "e_client_intern.h"
+#include "e_view_client_intern.h"
# include <gbm.h>
# include <wayland-tbm-server.h>
if (!(ec = copy_thread_data->hwc_window->ec)) goto end;
if (!e_client_cdata_get(ec)) goto end;
- if ((!evas_object_visible_get(ec->frame)) &&
+ if ((!e_view_client_visible_get(e_client_view_get(ec))) &&
(ec->exp_iconify.buffer_flush) &&
(e_policy_visibility_client_is_iconic(ec)))
goto end;
e_comp_wl_surface_attach(ec, copy_comp_buffer);
e_pixmap_image_refresh(ec->pixmap);
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
if (!comp_buffer)
e_comp_wl_surface_attach(ec, NULL);
if (!hwc_window->ec) return;
- if ((!evas_object_visible_get(hwc_window->ec->frame)) &&
+ if ((!e_view_client_visible_get(e_client_view_get(hwc_window->ec))) &&
(hwc_window->ec->exp_iconify.buffer_flush) &&
(e_policy_visibility_client_is_iconic(hwc_window->ec)))
return;
#include "e_egl_sync_intern.h"
#include "e_client_video_intern.h"
#include "e_client_intern.h"
-#include "e_comp_object_intern.h"
#include "e_utils_intern.h"
#include "services/e_service_quickpanel_intern.h"
#include "e_policy_private_data.h"
#include "e_policy_intern.h"
#include "e_display_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
# include <Evas_Engine_GL_Tbm.h>
# include <Evas_Engine_Software_Tbm.h>
e_client_geometry_get(ec, &x, &y, &w, &h);
- if ((!effect_client) && (!e_comp_object_color_visible_get(ec->frame)))
+ if ((!effect_client) && (!e_view_client_color_visible_get(e_client_view_get(ec))))
{
e_hwc_window_state_set(hwc_window, E_HWC_WINDOW_STATE_NONE, EINA_TRUE);
Eina_Bool vis_skip = EINA_FALSE;
E_Hwc_Window_Update_Data *update;
int pending_idx;
+ E_View *view;
eldbus_message_iter_arguments_append(iter, "as", &line_array);
if (hwc_window->ec)
{
- if ((hwc_window->ec->hwc_visible_skip) || (evas_object_data_get(hwc_window->ec->frame, "comp_skip")))
+ view = e_view_client_view_get(e_client_view_get(hwc_window->ec));
+ if ((hwc_window->ec->hwc_visible_skip) || (e_view_data_get(view, "comp_skip")))
vis_skip = EINA_TRUE;
}
#include "e_zone_intern.h"
#include "e_video_debug_intern.h"
#include "e_display_intern.h"
+#include "e_view_client_intern.h"
#include <device/board-internal.h>
if (ec->iconic) continue;
if (ec->visible == 0) continue;
if (!(e_client_visibility_get(ec) == 0 || e_client_visibility_get(ec) == 1)) continue;
- if (!ec->frame) continue;
- if (!evas_object_visible_get(ec->frame)) continue;
+ if (!e_client_view_get(ec)) continue;
+ if (!e_view_client_visible_get(e_client_view_get(ec))) continue;
if (e_comp_wl_subsurface_check(ec)) continue;
return ec;
{
if (ec->visible && !ec->input_only)
{
- if (e_comp_object_is_animating(ec->frame))
+ if (e_view_client_is_animating(e_client_view_get(ec)))
return EINA_TRUE;
}
}
E_CLIENT_FOREACH(ec)
{
if (ec->visible && !ec->input_only)
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
}
e_output_render(output);
{
if (e_object_is_del(E_OBJECT(ec))) continue;
if (e_client_util_ignored_get(ec)) continue;
- if (!ec->frame) continue;
+ if (!e_client_view_get(ec)) continue;
if (ec->is_cursor) continue;
if (!ec->visible) continue;
- if (!evas_object_visible_get(ec->frame)) continue;
+ if (!e_view_client_visible_get(e_client_view_get(ec))) continue;
if (e_comp_wl_subsurface_check(ec)) continue;
cdata = e_client_cdata_get(ec);
if (cdata && !cdata->mapped) continue;
#include "e_output_intern.h"
#include "e_comp_wl_video_buffer_intern.h"
#include "e_client_intern.h"
-#include "e_comp_object_intern.h"
#include "e_utils_intern.h"
+#include "e_view_client_intern.h"
#include <device/board-internal.h>
# include <tdm.h>
ERR("fail to e_plane_renderer_surface_queue_cancel_acquire");
}
- if (ec) e_comp_object_hwc_update_set(ec->frame, EINA_TRUE);
+ if (ec) e_view_client_hwc_update_set(e_client_view_get(ec), true);
return;
}
if (!e_plane_renderer_surface_queue_clear(renderer))
ERR("fail to e_plane_renderer_surface_queue_clear");
- if (e_comp_object_hwc_update_exists(ec->frame))
+ if (e_view_client_hwc_update_exists(e_client_view_get(ec)))
{
- e_comp_object_hwc_update_set(ec->frame, EINA_FALSE);
+ e_view_client_hwc_update_set(e_client_view_get(ec), false);
if (plane_trace_debug)
ELOGF("E_PLANE", "Display Plane(%p) zpos(%d) Client ec(%p, %s)",
if (!buffer) return NULL;
- if (!e_comp_object_hwc_update_exists(ec->frame)) return NULL;
+ if (!e_view_client_hwc_update_exists(e_client_view_get(ec))) return NULL;
if (plane_trace_debug)
ELOGF("E_PLANE", "Display Plane(%p) zpos(%d) Client ec(%p, %s)",
ec, plane, plane->zpos, ec, e_client_util_name_get(ec));
- e_comp_object_hwc_update_set(ec->frame, EINA_FALSE);
+ e_view_client_hwc_update_set(e_client_view_get(ec), false);
if (plane->is_fb)
{
buffer = cdata->buffer_ref.buffer;
if (!buffer) return NULL;
- if (!e_comp_object_hwc_update_exists(ec->frame)) return NULL;
+ if (!e_view_client_hwc_update_exists(e_client_view_get(ec))) return NULL;
if (plane_trace_debug)
ELOGF("E_PLANE", "Display Cursor Plane(%p) zpos(%d) ec(%p)",
ec, plane, plane->zpos, ec);
- e_comp_object_hwc_update_set(ec->frame, EINA_FALSE);
+ e_view_client_hwc_update_set(e_client_view_get(ec), false);
if (!e_plane_renderer_cursor_surface_refresh(renderer, ec))
{
EINA_SAFETY_ON_NULL_RETURN(renderer);
- visible = evas_object_visible_get(plane->ec->frame);
+ visible = e_view_client_visible_get(e_client_view_get(plane->ec));
plane->unset_counter = e_plane_renderer_render_count_get(fb_target->renderer);
_e_plane_set_counter_set(plane, ec);
- e_comp_object_hwc_update_set(ec->frame, EINA_TRUE);
+ e_view_client_hwc_update_set(e_client_view_get(ec), true);
if (plane->ec_redirected)
{
* the plane at the e_output_commit.
*/
if (!plane->is_fb && plane->ec && plane->set_counter &&
- evas_object_visible_get(plane->ec->frame))
+ e_view_client_visible_get(e_client_view_get(plane->ec)))
{
if (!plane->unset_ec_pending)
{
#include "e_video_debug_intern.h"
#include "e_client_intern.h"
#include "e_compositor_intern.h"
+#include "e_view_client_intern.h"
#include <wayland-tbm-server.h>
E_Video_Hwc *evh; \
evh = container_of(iface, E_Video_Hwc, iface)
+typedef struct
+{
+ int x;
+ int y;
+} E_Video_Point;
+
static Eina_Bool _e_video_hwc_render(E_Video_Hwc *evh, const char *func);
static void _e_video_hwc_buffer_show(E_Video_Hwc *evh, E_Comp_Wl_Video_Buf *vbuf, unsigned int transform);
static void _e_video_hwc_buffer_commit(E_Video_Hwc *evh, E_Comp_Wl_Video_Buf *vbuf);
_e_video_hwc_client_visible_get(E_Client *ec)
{
E_Client *offscreen_parent;
+ E_View_Client* view_client;
if (!e_pixmap_resource_get(ec->pixmap))
{
return EINA_FALSE;
}
- if (!evas_object_visible_get(ec->frame))
- {
- VDB("evas obj invisible", ec);
- return EINA_FALSE;
- }
+ view_client = e_client_view_get(ec);
+ if (view_client && e_view_client_visible_get(view_client))
+ return EINA_TRUE;
- return EINA_TRUE;
+ VDB("view invisible", ec);
+ return EINA_FALSE;
}
/* Video Buffer implementation */
}
static void
-_point_translate(Evas_Point *point, int x_axis, int y_axis)
+_point_translate(E_Video_Point *point, int x_axis, int y_axis)
{
point->x -= x_axis;
point->y -= y_axis;
}
static void
-_rect_to_points(Eina_Rectangle *rect, Evas_Point points[2])
+_rect_to_points(Eina_Rectangle *rect, E_Video_Point points[2])
{
points[0].x = rect->x;
points[0].y = rect->y;
}
static void
-_points_to_rect(Evas_Point points[2], Eina_Rectangle *rect)
+_points_to_rect(E_Video_Point points[2], Eina_Rectangle *rect)
{
rect->x = MIN(points[0].x, points[1].x);
rect->y = MIN(points[0].y, points[1].y);
{
Eina_Rectangle *output_rect, *buffer_rect;
Eina_Rectangle cropped_output_rect, screen_rect;
- Evas_Point points[2];
+ E_Video_Point points[2];
buffer_rect = &in_out->input_r;
output_rect = &in_out->tdm.output_r;
(r)->h = MAX(vs[0].y, vs[2].y) - (r)->y
static Eina_Bool
-_e_video_hwc_coords_to_rectangle_convert(Evas_Point p[4], Eina_Rectangle *rect, uint *transform)
+_e_video_hwc_coords_to_rectangle_convert(E_Video_Point p[4], Eina_Rectangle *rect, uint *transform)
{
Eina_Rectangle boundary = {0,};
Eina_Bool ret = EINA_FALSE;
_e_video_hwc_geometry_map_apply(E_Client *ec, E_Video_Hwc_Geometry *out)
{
E_Map *m;
- Evas_Point p[4];
+ E_Video_Point p[4];
Eina_Rectangle output_r;
uint transform;
int i;
EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(ec->frame, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e_client_view_get(ec), EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(out, EINA_FALSE);
m = e_client_map_get(ec);
return EINA_FALSE;
}
- /* NOTE Merge transform value from evas_map with E_Comp_Wl_Buffer_Viewport's one.
- * Since buffer.transform isn't applied using evas_map,
+ /* NOTE Merge transform value from E_Comp_Wl_Buffer_Viewport's one.
+ * Since buffer.transform isn't applied,
* it has to be taken into account here to apply buffer.transform
* and rotation of e_client_transform together. */
transform =
}
static void
-_e_video_hwc_cb_evas_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_video_hwc_cb_resize(struct wl_listener *listener, void *data)
{
- E_Video_Hwc *evh = data;
+ E_Video_Hwc *evh = wl_container_of(listener, evh, resize_listener);
+ E_View_Client* view_client = e_client_view_get(evh->ec);
/* Since video content will be displayed on the overlay plane,
* it's reasonable to keep the size of composite object to 1x1.
* Otherwise, it will cause memory usage to be increased unnecessarily. */
- evas_object_resize(evh->ec->frame, 1, 1);
+ if (view_client)
+ e_view_client_size_set(view_client, 1, 1);
evh->render.map = EINA_TRUE;
_e_video_hwc_render_queue(evh);
}
static void
-_e_video_hwc_cb_evas_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_video_hwc_cb_move(struct wl_listener *listener, void *data)
{
- E_Video_Hwc *evh = data;
+ E_Video_Hwc *evh = wl_container_of(listener, evh, move_listener);
evh->render.map = EINA_TRUE;
_e_video_hwc_render_queue(evh);
out->w = (out->w + 1) & ~1;
out->h = ec->comp_data->height_from_viewport;
- e_comp_object_frame_xy_unadjust(ec->frame, out->x, out->y, &out->x, &out->y);
- e_comp_object_frame_wh_unadjust(ec->frame, out->w, out->h, &out->w, &out->h);
+ e_view_client_frame_xy_unadjust(e_client_view_get(ec), out->x, out->y, &out->x, &out->y);
+ e_view_client_frame_wh_unadjust(e_client_view_get(ec), out->w, out->h, &out->w, &out->h);
}
/* convert from logical screen to physical output */
}
static void
-_e_video_hwc_cb_evas_show(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_video_hwc_cb_show(struct wl_listener *listener, void *data)
{
E_Video_Hwc *evh;
E_Client *ec;
- evh = data;
+ evh = wl_container_of(listener, evh, show_listener);
ec = evh->ec;
if (evh->need_force_render)
static void
_e_video_hwc_client_event_init(E_Video_Hwc *evh)
{
+ E_View_Client* view_client;
/* In order to try to redraw video whenever viewport changes. */
evh->surface_viewport_listener.notify = _e_video_hwc_cb_surface_viewport;
if (evh->ec->comp_data)
&evh->surface_viewport_listener);
}
- evas_object_event_callback_add(evh->ec->frame, EVAS_CALLBACK_SHOW,
- _e_video_hwc_cb_evas_show, evh);
- evas_object_event_callback_add(evh->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_video_hwc_cb_evas_resize, evh);
- evas_object_event_callback_add(evh->ec->frame, EVAS_CALLBACK_MOVE,
- _e_video_hwc_cb_evas_move, evh);
+ view_client = e_client_view_get(evh->ec);
+ if (view_client)
+ {
+ E_View* view = e_view_client_view_get(view_client);
+ evh->show_listener.notify = _e_video_hwc_cb_show;
+ evh->resize_listener.notify = _e_video_hwc_cb_resize;
+ evh->move_listener.notify = _e_video_hwc_cb_move;
+
+ e_view_event_listener_add(view, E_VIEW_SHOW, &evh->show_listener);
+ e_view_event_listener_add(view, E_VIEW_RESIZE, &evh->resize_listener);
+ e_view_event_listener_add(view, E_VIEW_MOVE, &evh->move_listener);
+ }
E_LIST_HANDLER_APPEND(evh->ec_event_handler, E_EVENT_CLIENT_SHOW,
_e_video_hwc_cb_client_show, evh);
static void
_e_video_hwc_client_event_deinit(E_Video_Hwc *evh)
{
+ E_View_Client* view_client;
/* links for listener have to be removed only in case comp_data is valid. */
if (evh->ec->comp_data)
wl_list_remove(&evh->surface_viewport_listener.link);
- evas_object_event_callback_del_full(evh->ec->frame, EVAS_CALLBACK_SHOW,
- _e_video_hwc_cb_evas_show, evh);
- evas_object_event_callback_del_full(evh->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_video_hwc_cb_evas_resize, evh);
- evas_object_event_callback_del_full(evh->ec->frame, EVAS_CALLBACK_MOVE,
- _e_video_hwc_cb_evas_move, evh);
+ view_client = e_client_view_get(evh->ec);
+ if (view_client)
+ {
+ E_View* view = e_view_client_view_get(view_client);
+ e_view_event_listener_del(view, E_VIEW_SHOW, &evh->show_listener);
+ e_view_event_listener_del(view, E_VIEW_RESIZE, &evh->resize_listener);
+ e_view_event_listener_del(view, E_VIEW_MOVE, &evh->move_listener);
+
+ evh->show_listener.notify = NULL;
+ evh->resize_listener.notify = NULL;
+ evh->move_listener.notify = NULL;
+ }
E_FREE_LIST(evh->ec_event_handler, ecore_event_handler_del);
}
/* destroy converter second */
E_FREE_FUNC(evh->pp, _e_video_hwc_pp_destroy);
- if (e_comp_object_mask_has(evh->ec->frame))
- e_comp_object_mask_set(evh->ec->frame, EINA_FALSE);
+ if (e_view_client_mask_has(e_client_view_get(evh->ec)))
+ e_view_client_mask_set(e_client_view_get(evh->ec), EINA_FALSE);
_e_video_hwc_client_event_deinit(evh);
E_Hwc_Policy hwc_policy;
E_Output *output;
E_Zone *zone;
+ E_View_Client* view_client;
zone = e_comp_zone_find_by_ec(ec);
EINA_SAFETY_ON_NULL_RETURN_VAL(zone, NULL);
/* Since video content will be displayed on the overlay plane,
* it's reasonable to keep the size of composite object to 1x1.
* Otherwise, it will cause memory usage to be increased unnecessarily. */
- evas_object_resize(ec->frame, 1, 1);
+ view_client = e_client_view_get(ec);
+ if (view_client)
+ e_view_client_size_set(view_client, 1, 1);
evh->hwc_policy = hwc_policy;
evh->e_output = output;
if (punch)
{
- if (!e_comp_object_mask_has(evh->ec->frame))
+ if (!e_view_client_mask_has(e_client_view_get(evh->ec)))
{
- e_comp_object_mask_set(evh->ec->frame, EINA_TRUE);
+ e_view_client_mask_set(e_client_view_get(evh->ec), true);
VIN("punched", evh->ec);
}
}
else
{
- if (e_comp_object_mask_has(evh->ec->frame))
+ if (e_view_client_mask_has(e_client_view_get(evh->ec)))
{
- e_comp_object_mask_set(evh->ec->frame, EINA_FALSE);
+ e_view_client_mask_set(e_client_view_get(evh->ec), false);
VIN("Un-punched", evh->ec);
}
}
Eina_Bool need_force_render;
Eina_Bool deleted;
+ struct wl_listener show_listener;
+ struct wl_listener resize_listener;
+ struct wl_listener move_listener;
};
/* For HWC interface */
#include "e_comp_wl_subsurface_intern.h"
#include "e_comp_wl_video_buffer_intern.h"
#include "e_video_debug_intern.h"
+#include "e_view_client_intern.h"
#include <tdm.h>
#include <tdm_helper.h>
Eina_Bool commit;
Eina_Bool vblank;
} wait_flag;
+ struct wl_listener hide_listener;
};
typedef struct _Tdm_Prop_Value
}
static void
-_e_video_hwc_planes_cb_evas_hide(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_video_hwc_planes_cb_hide(struct wl_listener *listener, void *data)
{
- E_Video_Hwc_Planes *evhp = data;
+ E_Video_Hwc_Planes *evhp = wl_container_of(listener, evhp, hide_listener);
/* if stand_alone is true, not hide */
if ((e_comp_wl_subsurface_check(evhp->base.ec)) &&
(e_comp_wl_subsurface_stand_alone_mode_get(evhp->base.ec)))
return;
- VIN("evas hide", evhp->base.ec);
+ VIN("e_client hide", evhp->base.ec);
if (evhp->tdm.layer)
{
VIN("unset layer: hide", evhp->base.ec);
static void
_e_video_hwc_planes_ec_event_deinit(E_Video_Hwc_Planes *evhp)
{
- E_Client *ec;
+ E_View_Client* view_client = e_client_view_get(evhp->base.ec);
- ec = evhp->base.ec;
-
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_HIDE,
- _e_video_hwc_planes_cb_evas_hide, evhp);
+ if (view_client)
+ {
+ e_view_event_listener_del(e_view_client_view_get(view_client), E_VIEW_HIDE, &evhp->hide_listener);
+ evhp->hide_listener.notify = NULL;
+ }
}
const char *
static void
_e_video_hwc_planes_ec_event_init(E_Video_Hwc_Planes *evhp, E_Client *ec)
{
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE,
- _e_video_hwc_planes_cb_evas_hide, evhp);
+ E_View_Client* view_client = e_client_view_get(ec);
+
+ if (view_client)
+ {
+ evhp->hide_listener.notify = _e_video_hwc_planes_cb_hide;
+ e_view_event_listener_add(e_view_client_view_get(view_client), E_VIEW_HIDE, &evhp->hide_listener);
+ }
}
static void
{
if (comp->wl_comp_data->ptr.num_devices == 0)
{
- e_pointer_object_set(comp->pointer, NULL, 0, 0);
+ e_pointer_view_set(comp->pointer, NULL, 0, 0);
e_comp_wl_input_pointer_enabled_set(EINA_TRUE);
}
comp->wl_comp_data->ptr.num_devices++;
if (comp->wl_comp_data->ptr.num_devices == 0)
{
e_comp_wl_input_pointer_enabled_set(EINA_FALSE);
- e_pointer_object_set(comp->pointer, NULL, 0, 0);
+ e_pointer_view_set(comp->pointer, NULL, 0, 0);
e_pointer_hide(e_comp->pointer);
_e_comp_screen_pointer_renew();
#include "e_blender_intern.h"
#include "e_client_intern.h"
#include "e_comp_object_intern.h"
+#include "e_view_client_intern.h"
+#include "e_view_intern.h"
#include <libds-tizen/blender.h>
static void
_e_blend_free(E_Blend *blend)
{
+ E_Client *ec;
+ E_View_Client *view_client;
+
ELOGF("E_BLENDER", "E_Blend:%p Free", blend->ec, blend);
- if (blend->ec)
+ ec = blend->ec;
+ if (ec)
{
- e_comp_object_render_op_set(blend->ec->frame, EVAS_RENDER_BLEND);
- evas_object_color_set(blend->ec->frame, 255, 255, 255, 255);
+ view_client = e_client_view_get(ec);
+ if (view_client)
+ {
+ e_view_client_render_op_set(view_client, E_VIEW_RENDER_BLEND);
+ e_view_color_set(e_view_client_view_get(view_client), 255, 255, 255, 255);
+ }
}
_e_blend_ec_set(blend, NULL);
_e_blend_cb_ds_tizen_blend_commit(struct wl_listener *listener, void *data)
{
E_Blend *blend;
+ E_Client *ec;
+ E_View_Client *view_client;
+ E_View *view;
struct ds_tizen_blend_state *state;
int a, r, g, b;
blend = container_of(listener, E_Blend, commit_listener);
if (!blend->ec) return;
+ ec = blend->ec;
+ view_client = e_client_view_get(ec);
+ if (!view_client) return;
+
+ view = e_view_client_view_get(view_client);
+ if (!view) return;
+
state = ds_tizen_blend_get_state(blend->tizen_blend);
if (!state) return;
blend->alpha = state->alpha;
blend->equation = state->equation;
- if (!blend->ec->argb) return;
+ if (!ec->argb) return;
a = r = g = b = 255;
a = (int)((blend->alpha / (double)0xffffffff) * a);
- evas_color_argb_premul(a, &r, &g, &b);
+ evas_color_argb_premul(a, &r, &g, &b); //TODO: FIXME: fix this with view
- evas_object_color_set(blend->ec->frame, r, g, b, a);
+ e_view_color_set(view, r, g, b, a);
if (blend->equation == DS_TIZEN_BLEND_EQUATION_PREMULTIPLIED)
- e_comp_object_render_op_set(blend->ec->frame, EVAS_RENDER_BLEND);
+ e_view_client_render_op_set(view_client, E_VIEW_RENDER_BLEND);
else if (blend->equation == DS_TIZEN_BLEND_EQUATION_NONE)
- e_comp_object_render_op_set(blend->ec->frame, EVAS_RENDER_COPY);
+ e_view_client_render_op_set(view_client, E_VIEW_RENDER_COPY);
}
static void
#include "e.h"
#include "e_blur_intern.h"
+#include "e_comp_canvas_intern.h"
+#include "e_view_intern.h"
+#include "e_view_image.h"
+#include "e_view_client_intern.h"
+
#include <pixman.h>
#include <libds-tizen/blur.h>
struct wl_listener commit_listener;
struct wl_listener destroy_listener;
+ struct wl_listener view_show_listener;
+ struct wl_listener view_hide_listener;
+ struct wl_listener view_resize_listener;
+ struct wl_listener view_move_listener;
+ struct wl_listener view_restack_listener;
+
E_Client *ec;
E_Object_Delfn *ec_delfn;
{
int x, y, w, h;
- Evas_Object *obj;
+ E_View_Image *view_image;
};
static int _e_blur_hooks_delete = 0;
static E_Blur_Manager *_blur_manager = NULL;
static void _e_blur_ec_set(E_Blur *blur, E_Client *ec);
+static void _e_blur_ec_unset(E_Blur *blur);
static void
_e_blur_hooks_clean(void)
_e_blur_object_create(int x, int y, int w, int h)
{
E_Blur_Object *blur_obj;
- Evas_Object *obj;
+ E_Canvas *canvas;
+ E_View_Tree *tree;
+ E_View_Image *view_image;
+ E_View *view;
blur_obj = E_NEW(E_Blur_Object, 1);
EINA_SAFETY_ON_FALSE_RETURN_VAL(blur_obj, NULL);
+ canvas = e_comp_canvas_get();
+ tree = e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_BOTTOM);
+ view_image = e_view_image_filled_create(tree);
+ EINA_SAFETY_ON_NULL_GOTO(view_image, fail);
+
+ e_view_image_snapshot_set(view_image, EINA_TRUE);
+
+ view = e_view_image_view_get(view_image);
+ e_view_name_set(view, "blur_obj");
+
blur_obj->x = x;
blur_obj->y = y;
blur_obj->w = w;
blur_obj->h = h;
-
- obj = evas_object_image_filled_add(e_comp->evas);
- EINA_SAFETY_ON_NULL_GOTO(obj, fail);
-
- evas_object_image_snapshot_set(obj, EINA_TRUE);
- evas_object_name_set(obj, "blur_obj");
-
- blur_obj->obj = obj;
+ blur_obj->view_image = view_image;
return blur_obj;
static void
_e_blur_object_destroy(E_Blur_Object *blur_obj)
{
- evas_object_del(blur_obj->obj);
+ E_View *view;
+
+ view = e_view_image_view_get(blur_obj->view_image);
+ e_view_destroy(view);
+
free(blur_obj);
}
ELOGF("E_BLUR", "E_Blur:%p Free", blur->ec, blur);
- _e_blur_ec_set(blur, NULL);
+ _e_blur_ec_unset(blur);
if (eina_list_count(blur->blur_objs))
{
static void
_e_blur_object_geometry_set(E_Blur_Object *blur_obj, E_Client *ec)
{
+ E_View_Client *view_client;
+
int ec_x, ec_y, ec_w, ec_h;
- int evas_x, evas_y, evas_w, evas_h;
+ int view_x, view_y, view_w, view_h;
double scale_w, scale_h;
- evas_object_geometry_get(ec->frame, &evas_x, &evas_y, &evas_w, &evas_h);
+ view_client = e_client_view_get(ec);
+ e_view_client_geometry_get(view_client, &view_x, &view_y, &view_w, &view_h);
if (e_client_transform_core_enable_get(ec))
{
e_client_geometry_get(ec, &ec_x, &ec_y, &ec_w, &ec_h);
- scale_w = (double)ec_w / (double)evas_w;
- scale_h = (double)ec_h / (double)evas_h;
+ scale_w = (double)ec_w / (double)view_w;
+ scale_h = (double)ec_h / (double)view_h;
- evas_object_geometry_set(blur_obj->obj,
+ e_view_image_geometry_set(blur_obj->view_image,
ec_x + blur_obj->x,
ec_y + blur_obj->y,
(int)((double)blur_obj->w * scale_w),
}
else
{
- evas_object_geometry_set(blur_obj->obj,
- evas_x + blur_obj->x,
- evas_y + blur_obj->y,
+ e_view_image_geometry_set(blur_obj->view_image,
+ view_x + blur_obj->x,
+ view_y + blur_obj->y,
blur_obj->w,
blur_obj->h);
}
Eina_List *l;
struct ds_tizen_blur_state *state;
Eina_Bool region_changed = EINA_FALSE, radius_changed = EINA_FALSE;
+ E_View *image_view, *client_view;
+ E_Canvas_Layer layer;
+ E_View_Tree *view_tree;
blur = container_of(listener, E_Blur, commit_listener);
if (!blur->ec) return;
_e_blur_object_geometry_set(blur_obj, blur->ec);
- efl_gfx_filter_program_set(blur_obj->obj, program, "image_filter");
- evas_object_layer_set(blur_obj->obj, blur->ec->layer);
- evas_object_stack_below(blur_obj->obj, blur->ec->frame);
+ e_view_image_gfx_filter_program_set(blur_obj->view_image, program,"image_filter");
+
+ image_view = e_view_image_view_get(blur_obj->view_image);
+ client_view = e_view_client_view_get(e_client_view_get(blur->ec));
+ layer = e_canvas_layer_find(e_comp_canvas_get(), client_view);
+ view_tree = e_canvas_layer_view_tree_get(e_comp_canvas_get(), layer);
+
+ e_view_reparent(image_view, view_tree);
+ e_view_place_below(image_view, client_view);
- if (evas_object_visible_get(blur->ec->frame))
- evas_object_show(blur_obj->obj);
+ if (e_view_client_visible_get(e_client_view_get(blur->ec)))
+ e_view_show(image_view);
blur->blur_objs = eina_list_append(blur->blur_objs, blur_obj);
{
EINA_LIST_FOREACH(blur->blur_objs, l, blur_obj)
{
- efl_gfx_filter_program_set(blur_obj->obj, program, "image_filter");
+ e_view_image_gfx_filter_program_set(blur_obj->view_image, program, "image_filter");
ELOGF("E_BLUR", "E_Blur:%p set blur_obj:%p radius:%d",
blur->ec, blur, blur_obj, blur->radius);
}
static void
-_e_blur_evas_cb_show(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_blur_cb_view_show(struct wl_listener *listener, void *data)
{
E_Blur *blur;
- Eina_List *l;
E_Blur_Object *blur_obj;
+ E_View *view;
+ Eina_List *l;
- if (!(blur = data)) return;
+ blur = container_of(listener, E_Blur, view_show_listener);
EINA_LIST_FOREACH(blur->blur_objs, l, blur_obj)
- evas_object_show(blur_obj->obj);
+ {
+ view = e_view_image_view_get(blur_obj->view_image);
+ e_view_show(view);
+ }
}
static void
-_e_blur_evas_cb_hide(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_blur_cb_view_hide(struct wl_listener *listener, void *data)
{
E_Blur *blur;
- Eina_List *l;
E_Blur_Object *blur_obj;
+ E_View *view;
+ Eina_List *l;
- if (!(blur = data)) return;
+ blur = container_of(listener, E_Blur, view_hide_listener);
EINA_LIST_FOREACH(blur->blur_objs, l, blur_obj)
- evas_object_hide(blur_obj->obj);
+ {
+ view = e_view_image_view_get(blur_obj->view_image);
+ e_view_hide(view);
+ }
}
static void
-_e_blur_evas_cb_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_blur_cb_view_resize(struct wl_listener *listener, void *data)
{
E_Blur *blur;
- Eina_List *l;
E_Blur_Object *blur_obj;
+ Eina_List *l;
- if (!(blur = data)) return;
+ blur = container_of(listener, E_Blur, view_resize_listener);
EINA_LIST_FOREACH(blur->blur_objs, l, blur_obj)
_e_blur_object_geometry_set(blur_obj, blur->ec);
}
static void
-_e_blur_evas_cb_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_blur_cb_view_move(struct wl_listener *listener, void *data)
{
E_Blur *blur;
- Eina_List *l;
E_Blur_Object *blur_obj;
+ Eina_List *l;
- if (!(blur = data)) return;
+ blur = container_of(listener, E_Blur, view_move_listener);
EINA_LIST_FOREACH(blur->blur_objs, l, blur_obj)
_e_blur_object_geometry_set(blur_obj, blur->ec);
}
static void
-_e_blur_evas_cb_restack(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_blur_cb_view_restack(struct wl_listener *listener, void *data)
{
E_Blur *blur;
- Eina_List *l;
E_Blur_Object *blur_obj;
+ E_View *view, *client_view;
+ E_View_Client *view_client;
+ Eina_List *l;
+
+ blur = container_of(listener, E_Blur, view_hide_listener);
+ if (!blur->ec) return;
+
+ view_client = e_client_view_get(blur->ec);
+ if (!view_client) return;
- if (!(blur = data)) return;
+ client_view = e_view_client_view_get(view_client);
EINA_LIST_FOREACH(blur->blur_objs, l, blur_obj)
- evas_object_stack_below(blur_obj->obj, obj);
+ {
+ view = e_view_image_view_get(blur_obj->view_image);
+ e_view_place_below(view, client_view);
+ }
}
static void
E_Blur *blur = data;
blur->ec_delfn = NULL;
- _e_blur_ec_set(blur, NULL);
+ _e_blur_ec_unset(blur);
}
static void
_e_blur_ec_set(E_Blur *blur, E_Client *ec)
{
+ E_View_Client *view_client;
+ E_View *view;
+
if (blur->ec == ec) return;
- if (blur->ec)
- {
- evas_object_event_callback_del(blur->ec->frame, EVAS_CALLBACK_SHOW,
- _e_blur_evas_cb_show);
- evas_object_event_callback_del(blur->ec->frame, EVAS_CALLBACK_HIDE,
- _e_blur_evas_cb_hide);
- evas_object_event_callback_del(blur->ec->frame, EVAS_CALLBACK_RESIZE,
- _e_blur_evas_cb_resize);
- evas_object_event_callback_del(blur->ec->frame, EVAS_CALLBACK_MOVE,
- _e_blur_evas_cb_move);
- evas_object_event_callback_del(blur->ec->frame, EVAS_CALLBACK_RESTACK,
- _e_blur_evas_cb_restack);
-
- if (blur->ec_delfn)
- {
- e_object_delfn_del(E_OBJECT(blur->ec), blur->ec_delfn);
- blur->ec_delfn = NULL;
- }
+ view_client = e_client_view_get(blur->ec);
+ view = e_view_client_view_get(view_client);
- blur->ec = NULL;
- }
+ blur->view_show_listener.notify = _e_blur_cb_view_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &blur->view_show_listener);
- if (ec)
- {
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW,
- _e_blur_evas_cb_show, blur);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE,
- _e_blur_evas_cb_hide, blur);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE,
- _e_blur_evas_cb_resize, blur);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE,
- _e_blur_evas_cb_move, blur);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESTACK,
- _e_blur_evas_cb_restack, blur);
-
- blur->ec_delfn = e_object_delfn_add(E_OBJECT(ec),
- _e_blur_cb_ec_free,
- blur);
- blur->ec = ec;
- }
+ blur->view_hide_listener.notify = _e_blur_cb_view_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &blur->view_hide_listener);
+
+ blur->view_resize_listener.notify = _e_blur_cb_view_resize;
+ e_view_event_listener_add(view, E_VIEW_RESIZE, &blur->view_resize_listener);
+
+ blur->view_move_listener.notify = _e_blur_cb_view_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &blur->view_move_listener);
+
+ blur->view_restack_listener.notify = _e_blur_cb_view_restack;
+ e_view_event_listener_add(view, E_VIEW_RESTACK, &blur->view_restack_listener);
+
+ blur->ec_delfn = e_object_delfn_add(E_OBJECT(ec),
+ _e_blur_cb_ec_free,
+ blur);
+ blur->ec = ec;
+}
+
+static void
+_e_blur_ec_unset(E_Blur *blur)
+{
+
+ if (!blur->ec) return;
+
+ blur->ec = NULL;
+
+ if (blur->ec_delfn)
+ {
+ e_object_delfn_del(E_OBJECT(blur->ec), blur->ec_delfn);
+ blur->ec_delfn = NULL;
+ }
+
+ wl_list_remove(&blur->view_restack_listener.link);
+ wl_list_remove(&blur->view_move_listener.link);
+ wl_list_remove(&blur->view_resize_listener.link);
+ wl_list_remove(&blur->view_hide_listener.link);
+ wl_list_remove(&blur->view_show_listener.link);
}
static void
#include "e_blur_intern.h"
#include "e_input_thread_client_intern.h"
#include "e_display_intern.h"
+#include "e_view_client_intern.h"
#include <tizen-extension-server-protocol.h>
#include <relative-pointer-unstable-v1-server-protocol.h>
if (send_size)
{
- if (e_comp_object_frame_exists(ec->frame))
+ if (e_view_client_frame_exists(e_client_view_get(ec)))
w = ec->client.w, h = ec->client.h;
else
w = ec->w, h = ec->h;
if (!ec || !ec->comp_data || e_object_is_del(E_OBJECT(ec))) return;
- e_comp_object_map_update(ec->frame);
+ e_view_client_map_update(e_client_view_get(ec));
cdata = ec->comp_data;
vp = &cdata->scaler.buffer_viewport;
}
}
- evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, NULL, NULL);
if (x != dx || y != dy)
e_subsurface_view_position_set(subsurface, dx, dy);
}
dx = ec->x;
dy = ec->y;
- evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, NULL, NULL);
if (x != dx || y != dy)
- evas_object_move(ec->frame, dx, dy);
+ e_view_position_set(e_view_client_view_get(e_client_view_get(ec)), dx, dy);
}
if (!cdata->viewport_transform)
{
if ((ec->hidden) || (ec->iconic))
{
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
// e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
}
else
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
}
topmost = e_comp_wl_topmost_parent_get(ec);
uint32_t serial;
int cx, cy, px, py;
- if (e_comp->pointer && e_comp->pointer->o_ptr &&
- !evas_object_visible_get(e_comp->pointer->o_ptr))
- e_pointer_object_set(e_comp->pointer, NULL, 0, 0);
+ if (e_comp->pointer && e_comp->pointer->view_client &&
+ !e_view_client_visible_get(e_comp->pointer->view_client))
+ e_pointer_view_set(e_comp->pointer, NULL, 0, 0);
if (!ec) return;
if (e_object_is_del(E_OBJECT(ec))) return;
ec->changes.buf_size = EINA_TRUE;
}
- if (e_comp_object_frame_exists(ec->frame)) return;
+ if (e_view_client_frame_exists(e_client_view_get(ec))) return;
window = &ec->comp_data->shell.window;
if ((!ec->borderless) && /* FIXME temporarily added this check code
* to prevent updating E_Client's size by frame */
(window->x || window->y || window->w || window->h))
{
- e_comp_object_frame_geometry_set(ec->frame,
+ e_view_client_frame_geometry_set(e_client_view_get(ec),
-window->x,
(window->x + window->w) - state->bw,
-window->y,
(window->y + window->h) - state->bh);
}
else
- e_comp_object_frame_geometry_set(ec->frame, 0, 0, 0, 0);
+ e_view_client_frame_geometry_set(e_client_view_get(ec), 0, 0, 0, 0);
}
static void
/* update the position */
if (ec->changes.pos)
{
- e_comp_object_frame_xy_unadjust(ec->frame,
+ e_view_client_frame_xy_unadjust(e_client_view_get(ec),
ec->x, ec->y,
&x, &y);
}
ec->client.w = state->bw;
ec->client.h = state->bh;
- e_comp_object_frame_wh_adjust(ec->frame,
+ e_view_client_frame_wh_adjust(e_client_view_get(ec),
ec->client.w, ec->client.h,
&nw, &nh);
e_client_size_set(ec, nw, nh);
buffer = e_pixmap_resource_get(ec->pixmap);
/* put state damages into surface */
- if (ec->frame)
+ if (e_client_view_get(ec))
{
/* FIXME: workaround for bad wayland egl driver which doesn't send damage request */
if (!eina_list_count(state->damages) && !eina_list_count(state->buffer_damages))
((cdata->buffer_ref.buffer->type == E_COMP_WL_BUFFER_TYPE_NATIVE) ||
(cdata->buffer_ref.buffer->type == E_COMP_WL_BUFFER_TYPE_TBM)))
{
- e_comp_object_damage(ec->frame,
+ e_view_client_damage(e_client_view_get(ec),
0, 0,
cdata->buffer_ref.buffer->w,
cdata->buffer_ref.buffer->h);
if (state->buffer_viewport.changed ||
!e_comp->wl_comp_data->available_hw_accel.underlay ||
!buffer || buffer->type != E_COMP_WL_BUFFER_TYPE_VIDEO)
- e_comp_object_damage(ec->frame, dmg->x, dmg->y, dmg->w, dmg->h);
+ e_view_client_damage(e_client_view_get(ec), dmg->x, dmg->y, dmg->w, dmg->h);
eina_rectangle_free(dmg);
}
Eina_Rectangle *rect;
Eina_Iterator *itr;
- e_comp_object_input_objs_del(ec->frame);
+ e_view_client_input_objs_del(e_client_view_get(ec));
itr = eina_tiler_iterator_new(src);
EINA_ITERATOR_FOREACH(itr, rect)
{
ELOGF("COMP", "Set Input Area x:%d, y:%d, w:%d, h:%d, ec(%dx%d), state(%dx%d)",
ec, rect->x, rect->y, rect->w, rect->h,
ec->w, ec->h, state->bw, state->bh);
- e_comp_object_input_area_set(ec->frame,
+ e_view_client_input_area_set(e_client_view_get(ec),
rect->x, rect->y,
rect->w, rect->h);
}
eina_tiler_free(src);
}
else
- e_comp_object_input_area_set(ec->frame, 0, 0, ec->w, ec->h);
+ e_view_client_input_area_set(e_client_view_get(ec), 0, 0, ec->w, ec->h);
eina_tiler_free(tmp);
ec->dead = 1;
/* check if internal animation is running */
- if (e_comp_object_is_animating(ec->frame)) return;
+ if (e_view_client_is_animating(e_client_view_get(ec))) return;
/* check if external animation is running */
- if (evas_object_data_get(ec->frame, "effect_running")) return;
+ if (e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), "effect_running")) return;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
}
EINTERN void
int x = 0, y = 0;
_e_comp_wl_surface_state_commit(ec, &ec->comp_data->pending);
- if (!e_comp_object_damage_exists(ec->frame))
+ if (!e_view_client_damage_exists(e_client_view_get(ec)))
{
if ((ec->comp_data->video_client) ||
(!e_client_video_hw_composition_check(ec)))
x = e_comp->pointer->hot.x;
y = e_comp->pointer->hot.y;
}
- e_pointer_object_set(e_comp->pointer, ec->frame, x, y);
+ e_pointer_view_set(e_comp->pointer, e_client_view_get(ec), x, y);
}
}
return EINA_TRUE;
Eina_List *l;
uint32_t serial;
- e_pointer_object_set(e_comp->pointer, NULL, 0, 0);
+ e_pointer_view_set(e_comp->pointer, NULL, 0, 0);
if (e_comp_wl->ptr.hide_tmr)
{
int x, y, w, h;
} config;
- if (!ec || !ec->frame) goto ret;
+ if (!ec || !e_client_view_get(ec)) goto ret;
if (e_object_is_del(E_OBJECT(ec))) goto ret;
bw = bh = 0;
out->w = (out->w + 1) & ~1;
out->h = ec->comp_data->height_from_viewport;
- e_comp_object_frame_xy_unadjust(ec->frame, out->x, out->y, &out->x, &out->y);
- e_comp_object_frame_wh_unadjust(ec->frame, out->w, out->h, &out->w, &out->h);
+ e_view_client_frame_xy_unadjust(e_client_view_get(ec), out->x, out->y, &out->x, &out->y);
+ e_view_client_frame_wh_unadjust(e_client_view_get(ec), out->w, out->h, &out->w, &out->h);
}
EINTERN Eina_Bool
ELOGF("COMP", "Set argb:%d", ec, ec->argb);
EC_CHANGED(ec);
_e_comp_wl_hook_call(E_COMP_WL_HOOK_CLIENT_ALPHA_CHANGE, ec);
- e_comp_object_alpha_set(ec->frame, EINA_FALSE);
+ e_view_client_alpha_set(e_client_view_get(ec), EINA_FALSE);
}
}
}
ELOGF("COMP", "Set argb:%d", ec, ec->argb);
EC_CHANGED(ec);
_e_comp_wl_hook_call(E_COMP_WL_HOOK_CLIENT_ALPHA_CHANGE, ec);
- e_comp_object_alpha_set(ec->frame, EINA_TRUE);
+ e_view_client_alpha_set(e_client_view_get(ec), EINA_TRUE);
}
}
}
if (eina_tiler_empty(region))
{
ELOGF("COMP", " |unset input rect", NULL);
- e_comp_object_input_objs_del(ec->frame);
- e_comp_object_input_area_set(ec->frame, -1, -1, 1, 1);
+ e_view_client_input_objs_del(e_client_view_get(ec));
+ e_view_client_input_area_set(e_client_view_get(ec), -1, -1, 1, 1);
}
else
eina_tiler_union(ec->comp_data->pending.input, region);
#include "e_comp_wl_intern.h"
#include "e_dnd_intern.h"
#include "e_comp_input_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
+#include "e_view_edje_intern.h"
#include <fcntl.h>
#include <unistd.h>
if (!(offer = wl_resource_get_user_data(resource)))
return;
+ if (offer->drag_enter)
+ wl_list_remove(&offer->ec_destroy_listener.link);
+
if (offer->source)
{
wl_list_remove(&offer->source_destroy_listener.link);
static void
_e_comp_wl_data_device_drag_finished(E_Drag *drag, E_Dnd_Drop_Type type)
{
- Evas_Object *o;
+ E_View *view = e_view_edje_part_swallow_get(drag->comp_edje, "e.swallow.content");
- o = edje_object_part_swallow_get(drag->comp_object, "e.swallow.content");
- if (eina_streq(evas_object_type_get(o), "e_comp_object"))
- edje_object_part_unswallow(drag->comp_object, o);
- evas_object_hide(o);
- evas_object_pass_events_set(o, 1);
+ if (eina_streq(evas_object_type_get(view->eo), "e_comp_object")) //TO DO : use view for type get
+ e_view_edje_part_unswallow(drag->comp_edje, view);
+ e_view_hide(view);
+ e_view_pass_events_set(view, 1);
if (e_comp_wl->drag != drag) return;
e_comp_wl->drag->button_mask = evas_pointer_button_down_mask_get(e_comp->evas);
if (drag_icon_ec)
{
- e_drag_object_set(e_comp_wl->drag, drag_icon_ec->frame);
+ e_drag_view_set(e_comp_wl->drag, e_view_client_view_get(e_client_view_get(drag_icon_ec)));
e_drag_reference_point_set(e_comp_wl->drag, drag_icon_ec->x, drag_icon_ec->y);
e_drag_resize(e_comp_wl->drag, drag_icon_ec->w, drag_icon_ec->h);
}
}
static void
-_e_comp_wl_data_device_target_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_comp_wl_data_device_target_del(struct wl_listener *listener, void *data)
{
E_Client *ec = data;
uint32_t serial;
int x, y;
E_Comp_Config *comp_conf;
+ E_Comp_Wl_Data_Offer *offer;
struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
if (!surface) return;
}
e_comp_wl->selection.target = ec;
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_DEL, _e_comp_wl_data_device_target_del, ec);
+ offer = wl_resource_get_user_data(offer_res);
+ offer->ec_destroy_listener.notify = _e_comp_wl_data_device_target_del;
+ e_view_event_listener_add(e_view_client_view_get(e_client_view_get(ec)), E_VIEW_DESTROY, &offer->ec_destroy_listener);
+ offer->drag_enter = EINA_TRUE;
if (e_client_transform_core_enable_get(ec))
{
E_Comp_Config *comp_conf;
struct wl_resource *res;
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_DEL, _e_comp_wl_data_device_target_del, ec);
if (e_comp_wl->selection.target == ec)
e_comp_wl->selection.target = NULL;
struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
Eina_Bool in_ask;
Ecore_Thread *th;
+
+ Eina_Bool drag_enter;
+ struct wl_listener ec_destroy_listener; //listener for destroy of ec
};
struct _E_Comp_Wl_Clipboard_Source
if (!e_comp_wl->ptr.ec->pointer_enter_sent) return;
if ((ptr = e_comp->pointer))
- e_pointer_object_set(ptr, ec->frame, ptr->hot.x, ptr->hot.y);
+ e_pointer_view_set(ptr, e_client_view_get(ec), ptr->hot.x, ptr->hot.y);
}
static void
return;
}
- e_pointer_object_set(e_comp->pointer, NULL, x, y);
+ e_pointer_view_set(e_comp->pointer, NULL, x, y);
ec->has_cursor_unset = EINA_TRUE;
ELOGF("COMP", "Cursor Set. has_cursor_unset:TRUE", ec);
return;
}
e_client_icccm_title_set(ec, "Cursor");
e_client_window_role_set(ec, "wl_pointer-cursor");
- evas_object_pass_events_set(ec->frame, 1);
+ e_view_pass_events_set(e_view_client_view_get(e_client_view_get(ec)), 1);
/* wl_pointer-cursor surface is always alpha window */
ec->argb = EINA_TRUE;
ELOGF("COMP", "Cursor Set. argb:%d", ec, ec->argb);
- e_comp_object_alpha_set(ec->frame, EINA_TRUE);
+ e_view_client_alpha_set(e_client_view_get(ec), EINA_TRUE);
EC_CHANGED(ec);
/* Set fuctions to prevent unwanted handling by shell */
#if 0
/* ignore cursor changes during resize/move I guess */
if (e_client_action_get()) return;
- e_pointer_object_set(e_comp->pointer, ec->frame, x, y);
+ e_pointer_view_set(e_comp->pointer, e_client_view_get(ec), x, y);
#endif
if (e_comp->pointer)
{
#include "e_zone_intern.h"
#include "e_utils_intern.h"
#include "e_security_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <tizen-remote-surface-server-protocol.h>
#include <tbm_surface.h>
if (!_ec->remote_surface.consumer) continue;
if (e_object_is_del(E_OBJECT(_ec))) continue;
if (e_client_util_ignored_get(_ec)) continue;
- if (!_ec->frame) continue;
+ if (!e_client_view_get(_ec)) continue;
if (!_ec->visible) continue;
if (_ec->visibility.skip) continue;
if ((e_client_visibility_get(_ec) != E_VISIBILITY_UNOBSCURED) &&
else
{
ec->visible = EINA_FALSE;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
ec->comp_data->mapped = 0;
}
consumer_ec = remote_surface->ec;
//object visibility of bind_ec
- if (!evas_object_visible_get(bind_ec->frame)) return;
+ if (!e_view_client_visible_get(e_client_view_get(bind_ec))) return;
//check wether effect of consumer_ec is running
- if ((consumer_ec) && (evas_object_data_get(consumer_ec->frame, "effect_running")))
+ if ((consumer_ec) && (e_view_data_get(e_view_client_view_get(e_client_view_get(consumer_ec)), "effect_running")))
{
RSMINF("Sending \"prebind\" is pending until EFFECT_END bind_ec(%p)",
remote_surface->ec,
remote_surface->bind_ec->comp_data->pending.new_attach = EINA_TRUE;
e_comp_wl_surface_attach(remote_surface->bind_ec, NULL);
- e_comp_object_render_update_del(remote_surface->bind_ec->frame);
+ e_view_client_render_update_del(e_client_view_get(remote_surface->bind_ec));
eina_hash_del(_rsm->bind_surface_hash, &remote_surface->bind_ec, remote_surface);
remote_surface->need_prebind = EINA_FALSE;
onscreen_parent = parent_provider->onscreen_parent;
if (!onscreen_parent) return EINA_TRUE;
- if (!evas_object_visible_get(ec->frame)) return EINA_TRUE;
+ if (!e_view_client_visible_get(e_client_view_get(ec))) return EINA_TRUE;
- evas_object_geometry_get(ec->frame, &fx, &fy, &fw, &fh);
+ e_view_client_geometry_get(e_client_view_get(ec), &fx, &fy, &fw, &fh);
e_comp_wl_subsurface_position_get(ec, &sx, &sy);
#include "e_comp_object_intern.h"
#include "e_desk_intern.h"
#include "e_config_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <xdg-shell-unstable-v5-server-protocol.h>
#include <xdg-shell-unstable-v6-server-protocol.h>
default: ev.button = e_comp_wl->ptr.button; break;
}
- e_comp_object_frame_xy_unadjust(ec->frame,
+ e_view_client_frame_xy_unadjust(e_client_view_get(ec),
wl_fixed_to_int(e_comp_wl->ptr.x),
wl_fixed_to_int(e_comp_wl->ptr.y),
&ev.canvas.x,
default: ev.button = e_comp_wl->ptr.button; break;
}
- e_comp_object_frame_xy_unadjust(ec->frame,
+ e_view_client_frame_xy_unadjust(e_client_view_get(ec),
wl_fixed_to_int(e_comp_wl->ptr.x),
wl_fixed_to_int(e_comp_wl->ptr.y),
&ev.canvas.x,
if (!ec) return;
- e_comp_object_signal_emit(ec->frame, "e,state,map", "e");
+ e_view_client_signal_emit(e_client_view_get(ec), "e,state,map", "e");
if (ec->use_splash)
{
ELOGF("LAUNCH", "SHOW real win after splash effect", ec);
- e_comp_object_signal_emit(ec->frame, "e,action,launch_real,done", "e");
+ e_view_client_signal_emit(e_client_view_get(ec), "e,action,launch_real,done", "e");
}
ec->use_splash = EINA_FALSE;
/* map this surface if needed */
ec->visible = EINA_TRUE;
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
ec->comp_data->mapped = EINA_TRUE;
}
EC_CHANGED(ec);
- e_comp_object_signal_emit(ec->frame, "e,action,map,done", "e");
+ e_view_client_signal_emit(e_client_view_get(ec), "e,action,map,done", "e");
}
static void
_e_shell_client_map_common_pre(ec);
/* force update */
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
e_comp_wl_surface_commit(ec);
ch = ec->h;
e_pixmap_size_get(ec->pixmap, &pw, &ph);
- evas_object_geometry_get(ec->frame, NULL, NULL, &cw, &ch);
+ e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &cw, &ch);
if (cw == 0 && ch == 0)
{
cw = ec->w;
if (ec->comp_data->mapped)
{
- e_comp_object_signal_emit(ec->frame, "e,state,unmap", "e");
+ e_view_client_signal_emit(e_client_view_get(ec), "e,state,unmap", "e");
/* need to save its last buffer to image file */
e_comp_wl_remote_surface_image_save(ec);
ec->visible = EINA_FALSE;
- evas_object_hide(ec->frame);
+ e_view_hide(e_view_client_view_get(e_client_view_get(ec)));
ec->comp_data->mapped = EINA_FALSE;
ec->visibility.last_sent_type = E_VISIBILITY_UNKNOWN;
#include "e_client_intern.h"
#include "e_comp_object_intern.h"
#include "e_alpha_mask_rect_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <tizen-extension-server-protocol.h>
+typedef struct
+{
+ E_Client *ec;
+ struct wl_listener destroy;
+ struct wl_listener view_restack;
+} View_Client_Restack_Data;
+
static Eina_List *hooks = NULL;
static Eina_List *handlers = NULL;
if (e_pixmap_resource_get(subc->pixmap) && !subc->comp_data->mapped)
{
subc->visible = EINA_TRUE;
- evas_object_show(subc->frame);
+ e_view_show(e_view_client_view_get(e_client_view_get(subc)));
subc->comp_data->mapped = 1;
}
_e_comp_wl_subsurface_show(subc);
if (e_pixmap_resource_get(subc->pixmap) && !subc->comp_data->mapped)
{
subc->visible = EINA_TRUE;
- evas_object_show(subc->frame);
+ e_view_show(e_view_client_view_get(e_client_view_get(subc)));
subc->comp_data->mapped = 1;
}
_e_comp_wl_subsurface_show(subc);
if (subc->comp_data->mapped)
{
subc->visible = EINA_FALSE;
- evas_object_hide(subc->frame);
+ e_view_hide(e_view_client_view_get(e_client_view_get(subc)));
subc->comp_data->mapped = 0;
}
_e_comp_wl_subsurface_hide(subc);
if (subc->comp_data->mapped)
{
subc->visible = EINA_FALSE;
- evas_object_hide(subc->frame);
+ e_view_hide(e_view_client_view_get(e_client_view_get(subc)));
subc->comp_data->mapped = 0;
}
_e_comp_wl_subsurface_hide(subc);
if (e_object_is_del(E_OBJECT(parent)) || !parent->comp_data) return NULL;
if (!parent->comp_data->sub.data)
- return (!evas_object_visible_get(parent->frame)) ? parent : NULL;
+ return (!e_view_visible_get(e_view_client_view_get(e_client_view_get(parent)))) ? parent : NULL;
- if (!evas_object_visible_get(parent->frame))
+ if (!e_view_visible_get(e_view_client_view_get(e_client_view_get(parent))))
{
if (e_pixmap_resource_get(parent->pixmap))
return parent;
e_comp_wl_surface_state_commit(ec, &sdata->cached);
- if (!e_comp_object_damage_exists(ec->frame))
+ if (!e_view_client_damage_exists(e_client_view_get(ec)))
{
if ((ec->comp_data->video_client) ||
(!e_client_video_hw_composition_check(ec)))
}
static void
-_e_comp_wl_subsurface_cb_comp_object_restack(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_view_client_restack_cb_destroy(struct wl_listener *listener, void *data)
{
+ View_Client_Restack_Data *restack_data;
+
+ restack_data = wl_container_of(listener, restack_data, destroy);
+
+ wl_list_remove(&restack_data->destroy.link);
+ wl_list_remove(&restack_data->view_restack.link);
+ free(restack_data);
+}
+
+static void
+_view_client_restack_cb_restack(struct wl_listener *listener, void *data)
+{
+ View_Client_Restack_Data *restack_data;
E_Client *ec, *above, *below;
- ec = data;
- if ((!ec) || (!ec->comp_data))
+ restack_data = wl_container_of(listener, restack_data, destroy);
+ ec = restack_data->ec;
+ if (!ec->comp_data)
return;
if (e_object_is_del(E_OBJECT(ec)))
_e_comp_wl_subsurface_cb_comp_object_add(void *data EINA_UNUSED, int type EINA_UNUSED, E_Event_Comp_Object *ev)
{
E_Client *ec;
+ View_Client_Restack_Data *restack_data;
+ E_View_Client *view_client;
ec = e_comp_object_client_get(ev->comp_object);
if (!ec)
* of evas smart member object mechanism. */
_e_comp_wl_subsurface_stack_update(ec);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESTACK, _e_comp_wl_subsurface_cb_comp_object_restack, ec);
+ restack_data = malloc(sizeof(*restack_data));
+ if (!restack_data)
+ goto end;
+
+ restack_data->ec = ec;
+
+ restack_data->destroy.notify = _view_client_restack_cb_destroy;
+ e_client_destroy_listener_add(ec, &restack_data->destroy);
+
+ view_client = e_client_view_get(ec);
+ restack_data->view_restack.notify = _view_client_restack_cb_restack;
+ e_view_event_listener_add(e_view_client_view_get(view_client), E_VIEW_RESTACK, &restack_data->view_restack);
end:
return ECORE_CALLBACK_RENEW;
#include "e_comp_wl_viewport_intern.h"
#include "e_utils_intern.h"
#include "e_client_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <tizen-extension-server-protocol.h>
E_Video_Object *vo;
E_Client *ec;
E_Event_Client *ev;
+ E_View_Client* view_client;
ev = event;
vo = data;
return ECORE_CALLBACK_PASS_ON;
ec = ev->ec;
- switch (e_client_visibility_get(ec))
+ view_client = e_client_view_get(ec);
+ if (view_client)
{
- case E_VISIBILITY_FULLY_OBSCURED:
- evas_object_hide(ec->frame);
- break;
- default:
- case E_VISIBILITY_UNOBSCURED:
- evas_object_show(ec->frame);
- break;
+ switch (e_client_visibility_get(ec))
+ {
+ case E_VISIBILITY_FULLY_OBSCURED:
+ e_view_client_hide(view_client);
+ break;
+ default:
+ case E_VISIBILITY_UNOBSCURED:
+ e_view_client_show(view_client);
+ break;
+ }
}
return ECORE_CALLBACK_PASS_ON;
#include "e_comp_canvas_intern.h"
#include "e_info_server_input_intern.h"
#include "e_info_server_intern.h"
+#include "e_view_client_intern.h"
#include <wayland-server.h>
#include <wayland-tbm-server.h>
E_Comp_Wl_Hook *subsurf_hook_create;
E_Comp_Wl_Hook *subsurf_hook_commit_to_cache;
+
+ struct wl_listener parent_show;
+ struct wl_listener parent_resize;
} E_Viewport;
static E_Viewport* _e_comp_wl_viewport_get_viewport(struct wl_resource *resource);
struct wl_resource *resource)
{
E_Viewport *viewport;
- Evas_Coord w = 0, h = 0;
+ E_View_Client *view_client;
+ int w = 0, h = 0;
viewport = _e_comp_wl_viewport_get_viewport(resource);
if (!viewport) return;
if (viewport->epc)
{
- evas_object_geometry_get(viewport->epc->frame,
- &viewport->parent_size.x, &viewport->parent_size.y,
- &viewport->parent_size.w, &viewport->parent_size.h);
+ view_client = e_client_view_get(viewport->epc);
+ e_view_client_geometry_get(view_client,
+ &viewport->parent_size.x, &viewport->parent_size.y,
+ &viewport->parent_size.w, &viewport->parent_size.h);
w = viewport->parent_size.w;
h = viewport->parent_size.h;
}
static void
-_e_comp_wl_viewport_cb_parent_show(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_comp_wl_viewport_cb_parent_show(struct wl_listener *listener, void *data)
{
- E_Viewport *viewport = data;
+ E_Viewport *viewport;
+ viewport = wl_container_of(listener, viewport, parent_show);
if (e_object_is_del(E_OBJECT(viewport->ec))) return;
PIN("Parent show: update viewport");
}
static void
-_e_comp_wl_viewport_cb_parent_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_comp_wl_viewport_cb_parent_resize(struct wl_listener *listener, void *data)
{
- E_Viewport *viewport = data;
- Evas_Coord old_w, old_h;
+ E_Viewport *viewport;
+ E_View_Client *view_client;
+ int old_w, old_h;
+ viewport = wl_container_of(listener, viewport, parent_resize);
if (e_object_is_del(E_OBJECT(viewport->epc))) return;
if (viewport->query_parent_size)
old_w = viewport->parent_size.w;
old_h = viewport->parent_size.h;
- evas_object_geometry_get(viewport->epc->frame,
- &viewport->parent_size.x,
- &viewport->parent_size.y,
- &viewport->parent_size.w,
- &viewport->parent_size.h);
+ view_client = e_client_view_get(viewport->epc);
+ e_view_client_geometry_get(view_client,
+ &viewport->parent_size.x,
+ &viewport->parent_size.y,
+ &viewport->parent_size.w,
+ &viewport->parent_size.h);
if ((old_w != viewport->parent_size.w) ||
(old_h != viewport->parent_size.h))
static void
_e_comp_wl_viewport_parent_set(E_Viewport *viewport, E_Client *epc)
{
+ E_View_Client *view_client;
+
if (viewport->epc == epc) return;
PIN("parent_set: new_parent(%p)", epc);
viewport->epc = epc;
- EINA_SAFETY_ON_NULL_RETURN(epc->frame);
-
- evas_object_event_callback_add(epc->frame, EVAS_CALLBACK_SHOW,
- _e_comp_wl_viewport_cb_parent_show,
- viewport);
- evas_object_event_callback_add(epc->frame, EVAS_CALLBACK_RESIZE,
- _e_comp_wl_viewport_cb_parent_resize,
- viewport);
+ view_client = e_client_view_get(epc);
+ viewport->parent_show.notify = _e_comp_wl_viewport_cb_parent_show;
+ e_view_client_show_listener_add(view_client, &viewport->parent_show);
+ viewport->parent_resize.notify = _e_comp_wl_viewport_cb_parent_resize;
+ e_view_client_resize_listener_add(view_client, &viewport->parent_resize);
}
static void
PIN("parent_unset");
- EINA_SAFETY_ON_NULL_GOTO(viewport->epc->frame, end);
-
- evas_object_event_callback_del_full(viewport->epc->frame,
- EVAS_CALLBACK_SHOW,
- _e_comp_wl_viewport_cb_parent_show,
- viewport);
- evas_object_event_callback_del_full(viewport->epc->frame,
- EVAS_CALLBACK_RESIZE,
- _e_comp_wl_viewport_cb_parent_resize,
- viewport);
-end:
+ wl_list_remove(&viewport->parent_show.link);
+ wl_list_remove(&viewport->parent_resize.link);
viewport->epc = NULL;
}
#include "e_presentation_time_intern.h"
#include "e_client_video_intern.h"
#include "e_client_intern.h"
+#include "e_view_client_intern.h"
#include <assert.h>
#include <libds/compositor.h>
e_subsurface_view_position_set(E_Subsurface *subsurface, int x, int y)
{
E_Subsurface_View *view = &subsurface->view;
+ E_View_Client *view_client;
if (!view->ec)
return;
- evas_object_move(view->ec->frame, x, y);
+ view_client = e_client_view_get(view->ec);
+ e_view_position_set(e_view_client_view_get(view_client), x, y);
e_client_transform_core_update(view->ec);
}
#include "e_comp_wl_intern.h"
#include "e_comp_wl_subsurface_intern.h"
#include "e_pixmap_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <wtz-foreign-server-protocol.h>
} comp_hook;
Eina_Bool has_cache_data;
+
+ struct wl_listener move_listener;
};
struct _E_Foreign_Shell
int x, y, w, h;
int32_t transform;
} state;
+
+ struct wl_listener restack_listener;
};
static const char *e_foreign_shell_role_name = "wtz_foreign_shell";
}
static void
-_e_exported_shell_cb_eo_move(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj, void *event EINA_UNUSED)
+_e_exported_shell_cb_move(struct wl_listener *listener, void *data)
{
E_Exported_Shell *es;
- es = data;
- evas_object_geometry_get(es->ec->frame, &es->x, &es->y, NULL, NULL);
+ es = wl_container_of(listener, es, move_listener);
+ e_view_client_geometry_get(e_client_view_get(es->ec), &es->x, &es->y, NULL, NULL);
if (es->foreign)
{
/* It's to update transform whenever position of comp object changes by
* sub-surface. Otherwise, final viewport by transform wouldn't represent
* changed position. */
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE,
- _e_exported_shell_cb_eo_move,
- es);
+ es->move_listener.notify = _e_exported_shell_cb_move;
+ e_view_event_listener_add(e_view_client_view_get(e_client_view_get(ec)), E_VIEW_MOVE, &es->move_listener);
/* FIXME workaround
* Use apply_viewport_signal due to the absence of commit signal for now. */
{
e_client_transform_core_remove(es->ec, es->transform);
- evas_object_event_callback_del(es->ec->frame, EVAS_CALLBACK_MOVE,
- _e_exported_shell_cb_eo_move);
+ e_view_event_listener_del(e_view_client_view_get(e_client_view_get(es->ec)), E_VIEW_MOVE, &es->move_listener);
wl_list_remove(&es->surface_commit_listener.link);
if (visible)
{
- if (!evas_object_visible_get(es->ec->frame))
+ if (!e_view_client_visible_get(e_client_view_get(es->ec)))
{
es->ec->comp_data->mapped = 1;
es->ec->visible = EINA_TRUE;
- evas_object_show(es->ec->frame);
+ e_view_client_show(e_client_view_get(es->ec));
}
}
else
{
- if (evas_object_visible_get(es->ec->frame))
+ if (e_view_client_visible_get(e_client_view_get(es->ec)))
{
es->ec->comp_data->mapped = 0;
es->ec->visible = EINA_FALSE;
- evas_object_hide(es->ec->frame);
+ e_view_client_hide(e_client_view_get(es->ec));
}
}
es->ec->client.w = w;
es->ec->client.h = h;
e_client_size_set(es->ec, w, h);
- evas_object_resize(es->ec->frame, w, h);
+ e_view_client_size_set(e_client_view_get(es->ec), w, h);
vp = &es->ec->comp_data->scaler.buffer_viewport;
vp->surface.width = w;
vp->surface.height = h;
vp->changed = EINA_TRUE;
- evas_object_geometry_get(es->ec->frame, &x, &y, NULL, NULL);
+ e_view_client_geometry_get(e_client_view_get(es->ec), &x, &y, NULL, NULL);
e_util_transform_viewport_set(es->transform, x, y, w, h);
e_client_transform_core_update(es->ec);
layer = e_client_layer_get(fs->exported->ec);
e_client_layer_set(fs->ec, layer);
- evas_object_stack_below(fs->ec->frame, fs->exported->ec->frame);
+ e_view_place_below(e_view_client_view_get(e_client_view_get(fs->ec)),
+ e_view_client_view_get(e_client_view_get(fs->exported->ec)));
}
static void
-_e_foreign_shell_cb_exported_object_restack(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_foreign_shell_cb_exported_restack(struct wl_listener *listener, void *data)
{
E_Foreign_Shell *fs;
- fs = data;
+ fs = wl_container_of(listener, fs, restack_listener);
_e_foreign_shell_place_under_exported(fs);
}
static void
_e_foreign_shell_exported_restack_handler_add(E_Foreign_Shell *fs)
{
- evas_object_event_callback_add(fs->exported->ec->frame,
- EVAS_CALLBACK_RESTACK,
- _e_foreign_shell_cb_exported_object_restack,
- fs);
+ fs->restack_listener.notify = _e_foreign_shell_cb_exported_restack;
+ e_view_event_listener_add(e_view_client_view_get(e_client_view_get(fs->exported->ec)),
+ E_VIEW_RESTACK, &fs->restack_listener);
}
static void
_e_foreign_shell_exported_restack_handler_remove(E_Foreign_Shell *fs)
{
- evas_object_event_callback_del_full(fs->exported->ec->frame,
- EVAS_CALLBACK_RESTACK,
- _e_foreign_shell_cb_exported_object_restack,
- fs);
+ e_view_event_listener_del(e_view_client_view_get(e_client_view_get(fs->exported->ec)),
+ E_VIEW_RESTACK, &fs->restack_listener);
}
static void
{
fs->ec->comp_data->mapped = 1;
fs->ec->visible = EINA_TRUE;
- evas_object_show(fs->ec->frame);
+ e_view_client_show(e_client_view_get(fs->ec));
}
}
else if (fs->ec->comp_data->mapped)
{
fs->ec->comp_data->mapped = 0;
fs->ec->visible = EINA_FALSE;
- evas_object_hide(fs->ec->frame);
+ e_view_client_hide(e_client_view_get(fs->ec));
}
}
fs->ec->client.w = w;
fs->ec->client.h = h;
e_client_size_set(fs->ec, w, h);
- evas_object_resize(fs->ec->frame, w, h);
+ e_view_client_size_set(e_client_view_get(fs->ec), w, h);
vp = &fs->ec->comp_data->scaler.buffer_viewport;
vp->surface.width = w;
#include "e_hwc_window_intern.h"
#include "e_input_backend_intern.h"
#include "e_input_thread_client_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <device/display.h>
#include <wayland-server.h>
ec = e_pixmap_client_get(psurf->cp);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
if (e_policy_client_is_keyboard(ec))
{
e_policy_wl_activate(E_Client *ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "REAL ACTIVATE", ec);
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "ACTIVATE", ec);
ec = e_pixmap_find_client_by_res_id(res_id);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
below_ec = e_pixmap_find_client_by_res_id(below_res_id);
EINA_SAFETY_ON_NULL_RETURN(below_ec);
- EINA_SAFETY_ON_NULL_RETURN(below_ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(below_ec));
ELOGF("TZPOL",
"ACTIVATE_BELOW|win:0x%08zx(res_id:%d)|below_win:0x%08zx(res_id:%d)",
ec = e_pixmap_find_client_by_res_id(res_id);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
above_ec = e_pixmap_find_client_by_res_id(above_res_id);
EINA_SAFETY_ON_NULL_RETURN(above_ec);
- EINA_SAFETY_ON_NULL_RETURN(above_ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(above_ec));
ELOGF("TZPOL",
"ACTIVATE_ABOVE|win:0x%08zx(res_id:%d)|above_win:0x%08zx(res_id:%d)",
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "RAISE", ec);
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "LOWER", ec);
ec = e_pixmap_find_client_by_res_id(res_id);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "LOWER by res id:%d", ec, res_id);
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "ROLE SET (role:%s)", ec, role);
e_client_window_role_set(ec, role);
e_policy_wl_iconify(E_Client *ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "Set ICONIFY BY CLIENT", ec);
e_policy_wl_uniconify(E_Client *ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
if (e_policy_visibility_client_uniconify(ec, 1))
return;
ec->changable_layer[E_CHANGABLE_LAYER_TYPE_ABOVE_NOTIFICATION].saved)
{
// restore original layer
- if (original_layer != evas_object_layer_get(ec->frame))
+ E_View *view = e_view_client_view_get(e_client_view_get(ec));
+ E_Layer ec_layer = e_canvas_util_layer_map(e_view_layer_index_get(view));
+ if (original_layer != ec_layer)
{
Eina_Bool pend = EINA_FALSE;
pend = e_policy_visibility_client_layer_lower(ec, original_layer);
if (state)
{
ec->bg_state = EINA_TRUE;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
e_pixmap_image_clear(ec->pixmap, 1);
}
else
cdata = e_client_cdata_get(ec);
if (cdata && cdata->mapped)
{
- evas_object_show(ec->frame);
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
+ e_view_client_show(e_client_view_get(ec));
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
}
}
}
ec->floating = floating;
ec->lock_client_location = EINA_FALSE;
- if (ec->frame)
+ if (e_client_view_get(ec))
{
if (floating)
{
ELOGF("TZPOL", "STACK Mode Set. mode:%d", ec, mode);
- if (ec->frame)
+ if (e_client_view_get(ec))
{
if (mode == TIZEN_POLICY_STACK_MODE_ABOVE)
{
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "Prepare SHOW (wait for buffer attach)", ec);
e_client_hide_by_request_set(ec, EINA_FALSE);
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "Prepare HIDE (wait for NULL buffer attach)", ec);
e_client_hide_by_request_set(ec, EINA_TRUE);
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "Set Maximize_direction. direction:%d", ec, direction);
_e_policy_set_pin_mode(E_Client *ec, Eina_Bool pinned)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "Set Pin mode to %d", ec, pinned);
e_client_pinned_set(ec, pinned);
_e_policy_set_modal(E_Client *ec, Eina_Bool modal)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
ELOGF("TZPOL", "Set modal to %d", ec, modal);
e_client_modal_state_set(ec, modal);
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;
- if (!ec->frame) continue;
+ if (!e_client_view_get(ec)) continue;
if (!ec->visible) continue;
if (ec->visibility.skip) continue;
if (ec->visible)
{
ec->visible = EINA_FALSE;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
ec->ignored = EINA_TRUE;
}
// if Launchscreen is replaced to cursor, than hide
e_comp_object_content_unset(ec->frame);
ec->visible = EINA_FALSE;
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
ec->ignored = EINA_TRUE;
}
else if (!tzlaunch_splash->replaced)
if (ec->first_mapped)
{
ELOGF("LAUNCH", "SHOW real win by replaced splash ec", ec);
- e_comp_object_signal_emit(ec->frame, "e,action,launch_real,done", "e");
+ e_view_client_signal_emit(e_client_view_get(ec), "e,action,launch_real,done", "e");
}
- e_comp_object_signal_emit(ec->frame, "e,action,launch,done", "e");
+ e_view_client_signal_emit(e_client_view_get(ec), "e,action,launch,done", "e");
}
}
Eina_Bool intercepted = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(splash->ec, EINA_FALSE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(splash->ec->frame, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e_client_view_get(splash->ec), EINA_FALSE);
ec = splash->ec;
ec->effect_type = _e_policy_wl_tzlaunch_effect_type_get(effect_type);
new_ec = pre_ec;
e_client_geometry_get(new_ec, NULL, NULL, &tw, &th);
if (tw <= 1 || th <= 1)
- evas_object_resize(new_ec->frame, e_comp->w, e_comp->h);
+ e_view_client_size_set(e_client_view_get(new_ec), e_comp->w, e_comp->h);
break;
}
eina_list_free(clients);
e_service_launcher_callee_register(new_ec, tzlaunch_splash->appid, tzlaunch_splash->path, SPLASH_GROUP_NAME);
}
- evas_object_show(new_ec->frame);
+ e_view_client_show(e_client_view_get(new_ec));
e_client_raise(new_ec);
tzlaunch_splash->ec = new_ec;
e_service_launcher_callee_register(old_ec, tzlaunch_splash->appid, tzlaunch_splash->path, SPLASH_GROUP_NAME);
}
- evas_object_show(old_ec->frame);
+ e_view_client_show(e_client_view_get(old_ec));
e_client_raise(old_ec);
}
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
if (state == TIZEN_INDICATOR_STATE_ON)
ind_state = E_INDICATOR_STATE_ON;
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
switch (mode)
{
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
if (vtype == TIZEN_INDICATOR_VISIBLE_TYPE_SHOWN)
vis_type = E_INDICATOR_VISIBLE_TYPE_SHOWN;
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
_e_policy_wl_tz_clipboard_set_client(res_tz_clipboard, ec);
e_service_cbhm_parent_set(ec, EINA_TRUE);
ec = e_client_from_surface_resource(surf);
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
e_service_cbhm_parent_set(ec, EINA_FALSE);
e_service_cbhm_hide();
#include "e_comp_object_intern.h"
#include "e_desk_intern.h"
#include "e_comp_wl_subsurface_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <assert.h>
#include <math.h>
e_surface_unmap(source->surface->surface);
// FIXME: Need to be done by another module handling view
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
}
static void
e_comp_wl_map_size_cal_from_viewport(ec);
// FIXME: This code is copied from e_comp_wl_map_apply()
- e_comp_object_map_update(ec->frame);
+ e_view_client_map_update(e_client_view_get(ec));
if (e_comp_wl_subsurface_check(ec))
{
}
}
- evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, NULL, NULL);
if (x != dx || y != dy)
e_subsurface_view_position_set(subsurface, dx, dy);
}
dx = ec->x;
dy = ec->y;
- evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, NULL, NULL);
if (x != dx || y != dy)
- evas_object_move(ec->frame, dx, dy);
+ e_view_position_set(e_view_client_view_get(e_client_view_get(ec)), dx, dy);
}
cdata = ec->comp_data;
+#include <Evas.h>
#include "e_map_intern.h"
+#include "e_view_intern.h"
#define E_MAP_INDEX_IN_RANGE(MAP, X) ((X >= 0) && (X < MAP->count))
return EINA_TRUE;
}
+
+E_API Eina_Bool
+e_map_util_points_populate_from_view(E_Map *em, E_View *view)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(em, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(view, EINA_FALSE);
+
+ evas_map_util_points_populate_from_object(em->map, view->eo);
+
+ return EINA_TRUE;
+}
+
+E_API Eina_Bool
+e_map_util_points_populate_from_view_full(E_Map *em, E_View *view, int z)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(em, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(view, EINA_FALSE);
+
+ evas_map_util_points_populate_from_object_full(em->map, view->eo, z);
+
+ return EINA_TRUE;
+}
+
E_API Eina_Bool
e_map_util_object_move_sync_set(E_Map *em, Eina_Bool enabled)
{
{
return e_config->comp_shadow_file;
}
+
+EINTERN int
+e_theme_edje_view_set(E_View_Edje *view, const char *category EINA_UNUSED, const char *group)
+{
+ return e_view_edje_file_set(view, e_config->comp_shadow_file, group);
+}
#include "e_intern.h"
#include "e_theme.h"
+#include "e_view_edje_intern.h"
EINTERN int e_theme_init(void);
EINTERN int e_theme_shutdown(void);
EINTERN const char *e_theme_edje_file_get(const char *category, const char *group);
+EINTERN int e_theme_edje_view_set(E_View_Edje *view, const char *category, const char *group);
#endif
#include "e_util_transform_intern.h"
+#include "e_view_client_intern.h"
#define E_UTIL_TRANSFORM_IS_ZERO(p) ((p) > -1e-6 && (p) < 1e-6)
#define E_UTIL_TRANSFORM_ROUND(x) ((x) >= 0 ? (int)((x) + 0.5) : (int)((x) - 0.5))
if (!rect || !ec) return;
- if ((ec->w == 0) && (ec->h == 0) && (ec->frame))
+ if ((ec->w == 0) && (ec->h == 0) && e_client_view_get(ec))
{
- evas_object_geometry_get(ec->frame, NULL, NULL, &w, &h);
+ e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
e_util_transform_rect_init(rect, ec->x, ec->y, w, h);
}
else
if (!out_x || !out_y) return;
if ((w <= 0) || (h <= 0)) return;
- /* get rectangle's points from vertices. becase transform matrix is different with Evas_Map
- * Evas_Map calculate using transformed rectangle's points, so to remove different these,
+ /* get rectangle's points from vertices. becase transform matrix is different with E_Map
+ * E_Map calculate using transformed rectangle's points, so to remove different these,
* calculate points using rectangle's points
*/
e_util_transform_vertices_pos_get(vetices, 0, &dx1, &dy1, NULL, NULL);
result_x = *out_x = E_UTIL_TRANSFORM_ROUND(dresult_x);
result_y = *out_y = E_UTIL_TRANSFORM_ROUND(dresult_y);
- /* this logic is added because Evas_Map doesn't do round.
- * so check whether transformed result from Evas_Map is roundable.
+ /* this logic is added because E_Map doesn't do round.
+ * so check whether transformed result from E_Map is roundable.
* If the first digit after decimal point of result is greater than 5(roundable),
* add 1 to the inverted result.
*/
#include "e_grabinput_intern.h"
#include "e_comp_intern.h"
#include "e_comp_wl_input.h"
+#include "e_comp_canvas_intern.h"
+#include "e_view_client_intern.h"
+#include "e_view_edje_intern.h"
+#include "e_view_rect.h"
struct _E_Drag_Hook
{
static int
_e_drag_finalize(E_Drag *drag, int x, int y)
{
+ E_View_Rect *rect;
+ const int color[4] = {0, 0, 0, 0};
+
if (_drag_win) return 0;
_drag_win = e_comp->ee_win;
if (!e_comp_grab_input(1, 1))
}
drag->input_grab = EINA_TRUE;
- if (!drag->object)
+ if (!drag->view)
{
- e_drag_object_set(drag, evas_object_rectangle_add(drag->evas));
- evas_object_color_set(drag->object, 0, 0, 0, 0);
+ rect = e_view_rect_create(e_canvas_layer_view_tree_get(e_comp_canvas_get(), E_CANVAS_LAYER_CLIENT_DRAG),
+ 1, 1, color);
+ e_drag_view_set(drag, e_view_rect_view_get(rect));
}
drag->angle = e_comp->pointer->rotation;
e_drag_move(drag, x, y);
e_drag_resize(drag, drag->w, drag->h);
drag->visible = 1;
- evas_object_show(drag->comp_object);
- evas_object_show(drag->object);
+ e_view_show(e_view_edje_view_get(drag->comp_edje));
+ e_view_show(drag->view);
_drag_current = drag;
return 1;
drag->w = 24;
drag->h = 24;
- drag->evas = e_comp->evas;
-
drag->cb.finished = finished_cb;
return drag;
}
EINTERN void
-e_drag_object_set(E_Drag *drag, Evas_Object *object)
+e_drag_view_set(E_Drag *drag, E_View *view)
{
- EINA_SAFETY_ON_NULL_RETURN(object);
- EINA_SAFETY_ON_TRUE_RETURN(!!drag->object);
+ EINA_SAFETY_ON_NULL_RETURN(view);
+ EINA_SAFETY_ON_TRUE_RETURN(!!drag->view);
if (drag->visible)
- evas_object_show(object);
+ e_view_show(view);
else
- evas_object_hide(object);
- drag->object = object;
- drag->comp_object = e_comp_object_util_add(object);
- evas_object_layer_set(drag->comp_object, E_LAYER_CLIENT_DRAG);
- evas_object_name_set(drag->comp_object, "E Drag");
- evas_object_pass_events_set(drag->comp_object, 1);
+ e_view_hide(view);
+ drag->view = view;
+ e_view_reparent(view, e_canvas_layer_view_tree_get(e_comp_canvas_get(), E_CANVAS_LAYER_CLIENT_DRAG));
+ drag->comp_edje = e_view_edje_util_add(view);
+ e_view_name_set(e_view_edje_view_get(drag->comp_edje), "E Drag");
+ e_view_pass_events_set(e_view_edje_view_get(drag->comp_edje), 1);
}
EINTERN void
e_drag_move(E_Drag *drag, int x, int y)
{
int cur_x, cur_y;
- evas_object_geometry_get(drag->comp_object, &cur_x, &cur_y, NULL, NULL);
+ e_view_edje_geometry_get(drag->comp_edje, &cur_x, &cur_y, NULL, NULL);
if ((cur_x == x + drag->dx) && (cur_y == y + drag->dy)) return;
drag->x = x;
drag->y = y;
if (_drag_current == drag)
{
- evas_object_move(drag->comp_object, x + drag->dx, y + drag->dy);
- _e_drag_map_apply(drag);
+ e_view_position_set(e_view_edje_view_get(drag->comp_edje), x + drag->dx, y + drag->dy);
+ _e_drag_map_apply(drag);
}
}
drag->w = w;
if (_drag_current == drag)
{
- evas_object_resize(drag->comp_object, w, h);
+ e_view_edje_size_set(drag->comp_edje, w, h);
_e_drag_map_apply(drag);
}
}
static void
_e_drag_end(E_Drag *drag, E_Dnd_Drop_Type type)
{
- evas_object_hide(drag->comp_object);
+ e_view_hide(e_view_edje_view_get(drag->comp_edje));
_e_drag_hook_call(E_DRAG_HOOK_DRAG_END, drag);
_drag_current = NULL;
}
- evas_object_hide(drag->comp_object);
- E_FREE_FUNC(drag->comp_object, evas_object_del);
+ if (drag->comp_edje)
+ {
+ e_view_hide(e_view_edje_view_get(drag->comp_edje));
+ e_view_destroy(e_view_edje_view_get(drag->comp_edje));
+ drag->comp_edje = NULL;
+ }
free(drag);
if (input_grab)
e_comp_ungrab_input(1, 1);
int angle, drag_client_w, drag_client_h;
E_Map *map = NULL, *new_map = NULL;
Eina_Bool need_map_enable;
+ E_View *view;
angle = drag->angle;
else if (angle == 270)
angle = 90;
- need_map_enable = evas_object_map_enable_get(e_comp_wl->drag_client->frame) || (angle != 0);
+ view = e_view_client_view_get(e_client_view_get(e_comp_wl->drag_client));
+ need_map_enable = e_view_map_enable_get(view) || (angle != 0);
if (!need_map_enable) return;
map = e_client_map_get(e_comp_wl->drag_client);
e_map_util_points_populate_from_geometry(new_map, drag->x, drag->y, drag_client_w, drag_client_h, 0);
e_map_util_rotate(new_map, angle, drag->x, drag->y);
e_map_util_object_move_sync_set(new_map, EINA_TRUE);
- e_comp_object_map_set(drag->comp_object, new_map);
- e_comp_object_map_enable_set(drag->comp_object, EINA_TRUE);
+ e_view_edje_map_set(drag->comp_edje, new_map);
+ e_view_edje_map_enable_set(drag->comp_edje, true);
fin:
if (map) e_map_free(map);
#include "e_intern.h"
#include "e_dnd.h"
+#include "e_view_intern.h"
+#include "e_view_edje_intern.h"
#define E_DRAG_TYPE 0xE0b0100f
E_Drag_Finished_Cb finished;
} cb;
- Evas *evas;
- Evas_Object *comp_object;
- Evas_Object *object;
+ E_View *view;
+ E_View_Edje *comp_edje;
int x, y, w, h;
int dx, dy;
EINTERN E_Drag *e_drag_current_get(void);
/* x and y are the top left coords of the object that is to be dragged */
EINTERN E_Drag *e_drag_new(int x, int y, E_Drag_Finished_Cb finished_cb);
-EINTERN Evas *e_drag_evas_get(const E_Drag *drag);
-EINTERN void e_drag_object_set(E_Drag *drag, Evas_Object *object);
+EINTERN void e_drag_view_set(E_Drag *drag, E_View *view);
EINTERN void e_drag_reference_point_set(E_Drag *drag, int x, int y);
EINTERN void e_drag_move(E_Drag *drag, int x, int y);
EINTERN void e_drag_resize(E_Drag *drag, int w, int h);
#include "e_focus_policy_iface.h"
#include "e_zone_intern.h"
#include "e_client_intern.h"
-#include "e_comp_object_intern.h"
#include "e_comp_intern.h"
#include "e_policy_visibility_intern.h"
#include "e_desk_intern.h"
#include "e_config_intern.h"
+#include "e_view_client_intern.h"
typedef struct _E_Focus_Policy_History_Impl E_Focus_Policy_History;
typedef struct _E_Focus_Policy_History_Client E_Focus_Policy_History_Client;
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 (!e_view_client_visible_get(e_client_view_get(ec))) continue;
if (ec->iconic) continue;
if (ec->bg_state) continue;
if (e_client_check_really_iconified(ec))
return EINA_FALSE;
- if (!evas_object_visible_get(ec->frame) &&
+ if (!e_view_client_visible_get(e_client_view_get(ec)) &&
!eina_list_data_find(history_policy->defer_focus_stack, ec))
return EINA_FALSE;
break;
E_Focus_Policy_History *history_policy;
E_Focus_Policy_History_Client *history_client;
E_Client *ec;
- Evas_Object *obj;
+ E_View_Client *view_client;
history_policy = wl_container_of(listener, history_policy, zone_client_add);
E_FOCUS_HISTORY_TRACE(history_policy, ec);
- obj = ec->frame;
- EINA_SAFETY_ON_NULL_RETURN(obj);
+ view_client = e_client_view_get(ec);
+ EINA_SAFETY_ON_NULL_RETURN(view_client);
history_client = E_NEW(E_Focus_Policy_History_Client, 1);
EINA_SAFETY_ON_NULL_RETURN(history_client);
// e_comp_object listeners
history_client->comp_object_lower_done.notify = _focus_policy_history_cb_comp_object_lower_done;
- e_comp_object_lower_done_listener_add(obj, &history_client->comp_object_lower_done);
+ e_view_client_lower_done_listener_add(view_client, &history_client->comp_object_lower_done);
history_client->comp_object_show.notify = _focus_policy_history_cb_comp_object_show;
- e_comp_object_show_listener_add(obj, &history_client->comp_object_show);
+ e_view_client_show_listener_add(view_client, &history_client->comp_object_show);
history_client->comp_object_hide.notify = _focus_policy_history_cb_comp_object_hide;
- e_comp_object_hide_listener_add(obj, &history_client->comp_object_hide);
+ e_view_client_hide_listener_add(view_client, &history_client->comp_object_hide);
ELOGF("FOCUS_HISTORY", "zone_client_add | ", ec);
}
#include "e_client_intern.h"
#include "e_desk_intern.h"
#include "e_config_intern.h"
+#include "e_view_client_intern.h"
typedef struct _E_Focus_Policy_Topmost_Impl E_Focus_Policy_Topmost;
typedef struct _E_Focus_Policy_Topmost_Client E_Focus_Policy_Topmost_Client;
above_ec = e_client_check_fully_contain_by_above(ec, EINA_FALSE);
if (above_ec)
{
- if (!evas_object_visible_get(above_ec->frame))
+ if (!e_view_client_visible_get(e_client_view_get(above_ec)))
return EINA_TRUE;
child_ec = e_client_check_obscured_by_children_group(ec);
#include "e_magnifier_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#define E_MAGNIFIER_SMART_DATA_GET(obj, ptr) \
E_Magnifier_Smart_Data *ptr = evas_object_smart_data_get(obj);
if (!ptr) return
typedef struct _E_Magnifier_Smart_Data E_Magnifier_Smart_Data;
+typedef struct _E_Magnifier_Listener E_Magnifier_Listener;
struct _E_Magnifier_Smart_Data
{
Eina_Bool enabled;
};
+struct _E_Magnifier_Listener
+{
+ E_Client *ec;
+
+ // view listener
+ struct wl_listener move_listener;
+ struct wl_listener resize_listener;
+};
+
EVAS_SMART_SUBCLASS_NEW(E_MAGNIFIER_SMART_OBJ_TYPE, _e_magnifier,
Evas_Smart_Class, Evas_Smart_Class,
evas_object_smart_clipped_class_get, NULL);
static void _e_magnifier_owner_unset(E_Client *ec);
static Evas_Object *_e_magnifier_mgr = NULL;
+static E_Magnifier_Listener *_e_magnifier_listener = NULL;
static Eina_Bool
_e_magnifier_smart_init(void)
Eina_Bool ret;
if (!ec) return EINA_FALSE;
- if (!ec->frame) return EINA_FALSE;
+ if (!e_client_view_get(ec)) return EINA_FALSE;
if (ec->is_magnifier) return EINA_FALSE;
if (ec->magnifier_proxy)
{
if (e_client_util_ignored_get(ec)) continue;
desk2 = e_zone_desk_find_by_ec(zone, ec);
if (desk2 != desk) continue;
- if (!ec->frame) continue;
+ if (!e_client_view_get(ec)) continue;
if (ec->is_magnifier) continue;
ret = _e_magnifier_proxy_ec_new(ec);
_e_magnifier_apply_zoom(_e_magnifier_mgr);
}
-
-
static void
-_e_magnifier_cb_owner_move_resize(void *data EINA_UNUSED,
- Evas *e EINA_UNUSED,
- Evas_Object *obj,
- void *event_info EINA_UNUSED)
+_e_magnifier_cb_owner_move_resize(E_Client *ec)
{
int x, y, w, h;
int nx, ny, nw, nh;
- evas_object_geometry_get(obj, &x, &y, &w, &h);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, &w, &h);
E_MAGNIFIER_SMART_DATA_GET_OR_RETURN(_e_magnifier_mgr, sd);
_e_magnifier_apply_zoom(_e_magnifier_mgr);
}
+static void
+_e_magnifier_cb_owner_move(struct wl_listener *listener, void *data)
+{
+ E_Magnifier_Listener *magnifier_listener;
+ E_Client *ec;
+
+ magnifier_listener = wl_container_of(listener, magnifier_listener, move_listener);
+ if (EINA_UNLIKELY(!magnifier_listener))
+ return;
+
+ ec = magnifier_listener->ec;
+
+ _e_magnifier_cb_owner_move_resize(ec);
+}
+
+static void
+_e_magnifier_cb_owner_resize(struct wl_listener *listener, void *data)
+{
+ E_Magnifier_Listener *magnifier_listener;
+ E_Client *ec;
+
+ magnifier_listener = wl_container_of(listener, magnifier_listener, resize_listener);
+ if (EINA_UNLIKELY(!magnifier_listener))
+ return;
+
+ ec = magnifier_listener->ec;
+
+ _e_magnifier_cb_owner_move_resize(ec);
+}
EINTERN int
e_magnifier_init(void)
static void
_e_magnifier_owner_set(E_Client *ec)
{
+ E_View *view;
+
if (!ec) return;
+ _e_magnifier_listener = E_NEW(E_Magnifier_Listener, 1);
+ if (!_e_magnifier_listener)
+ {
+ ELOGF("MAGNIFIER", "Fail to alloc listener..", ec);
+ return;
+ }
+
ec->is_magnifier = EINA_TRUE;
ec->exp_iconify.deiconify_update = EINA_FALSE;
e_client_layer_set(ec, E_LAYER_CLIENT_ALERT_HIGH);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_magnifier_cb_owner_move_resize, NULL);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _e_magnifier_cb_owner_move_resize, NULL);
+ _e_magnifier_listener->ec = ec;
+ view = e_view_client_view_get(e_client_view_get(ec));
+ _e_magnifier_listener->move_listener.notify = _e_magnifier_cb_owner_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &_e_magnifier_listener->move_listener);
+ _e_magnifier_listener->resize_listener.notify = _e_magnifier_cb_owner_resize;
+ e_view_event_listener_add(view, E_VIEW_RESIZE, &_e_magnifier_listener->resize_listener);
}
static void
ec->is_magnifier = EINA_FALSE;
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_MOVE, _e_magnifier_cb_owner_move_resize);
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_RESIZE, _e_magnifier_cb_owner_move_resize);
+ if (_e_magnifier_listener)
+ {
+ wl_list_remove(&_e_magnifier_listener->move_listener.link);
+ wl_list_remove(&_e_magnifier_listener->resize_listener.link);
+ E_FREE(_e_magnifier_listener);
+ _e_magnifier_listener = NULL;
+ }
}
static Eina_Bool
#include "e_place_intern.h"
#include "e_input_device_intern.h"
#include "e_desk_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
EINTERN void
e_place_zone_region_smart_cleanup(E_Zone *zone)
EINA_LIST_FREE(clients, ec)
{
int new_x, new_y;
+ E_View *view = e_view_client_view_get(e_client_view_get(ec));
e_place_zone_region_smart(zone, clients, ec->x, ec->y,
ec->w, ec->h, &new_x, &new_y);
- evas_object_move(ec->frame, new_x, new_y);
+ e_view_position_set(view, new_x, new_y);
}
}
#include "e_pointer_intern.h"
#include "e_input_device_intern.h"
#include "e_client_intern.h"
+#include "e_comp_canvas.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
/* local variables */
static Eina_List *_ptrs = NULL;
E_Client *ec;
double ratio = 1.0;
int hot_x = 0, hot_y = 0;
+ E_View *view;
- if (!ptr->o_ptr) return;
+ if (!ptr->view_client) return;
+ view = e_view_client_view_get(ptr->view_client);
+ EINA_SAFETY_ON_NULL_RETURN(view);
- ec = e_comp_object_client_get(ptr->o_ptr);
+ ec = e_view_data_get(view, "E_Client");
EINA_SAFETY_ON_NULL_RETURN(ec);
rotation = ptr->rotation;
- evas_object_geometry_get(ec->frame, NULL, NULL, &cursor_w, &cursor_h);
+ e_view_client_geometry_get(ptr->view_client, NULL, NULL, &cursor_w, &cursor_h);
_e_pointer_configured_output_resolution_ratio_get(ec, &ratio);
if (ratio != 1.0)
break;
}
- evas_object_move(ptr->o_ptr, nx, ny);
+ e_view_position_set(view, nx, ny);
}
static void
E_Client *ec;
int rotation = 0;
double ratio = 1.0;
+ E_View *view;
EINA_SAFETY_ON_NULL_RETURN(ptr);
- if (!ptr->o_ptr) return;
+ if (!ptr->view_client) return;
- ec = e_comp_object_client_get(ptr->o_ptr);
+ view = e_view_client_view_get(ptr->view_client);
+ EINA_SAFETY_ON_NULL_RETURN(view);
+
+ ec = e_view_data_get(view, "E_Client");
EINA_SAFETY_ON_NULL_RETURN(ec);
_e_pointer_configured_output_resolution_ratio_get(ec, &ratio);
return;
}
- evas_object_geometry_get(ec->frame, &x, &y, &w, &h);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, &w, &h);
map = e_map_new();
EINA_SAFETY_ON_NULL_RETURN(map);
- e_map_util_points_populate_from_object_full(map, ec->frame, 0);
+ e_map_util_points_populate_from_view_full(map, view, 0);
if (ratio != 1.0)
{
}
static void
-_e_pointer_cb_object_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_pointer_cb_view_del(struct wl_listener *listener, void *data)
{
- E_Pointer *ptr = (E_Pointer *)data;
+ E_Pointer *ptr;
+
+ ptr = wl_container_of(listener, ptr, destroy_listener);
+ if (ptr->view_client)
+ {
+ wl_list_remove(&ptr->destroy_listener.link);
+ ptr->view_client = NULL;
+ }
- ptr->o_ptr = NULL;
ptr->device = E_POINTER_NONE;
ptr->hot.x = 0;
ptr->hot.y = 0;
}
static void
-_e_pointer_object_set(E_Pointer *ptr, Evas_Object *obj)
+_e_pointer_view_set(E_Pointer *ptr, E_View_Client *view_client)
{
- if (ptr->o_ptr == obj) return;
+ E_View *view;
+
+ if (ptr->view_client == view_client) return;
- if (ptr->o_ptr)
+ if (ptr->view_client)
{
- evas_object_event_callback_del_full(ptr->o_ptr, EVAS_CALLBACK_DEL, _e_pointer_cb_object_del, ptr);
- ptr->o_ptr = NULL;
+ view = e_view_client_view_get(ptr->view_client);
+ wl_list_remove(&ptr->destroy_listener.link);
+ ptr->destroy_listener.notify = NULL;
+ ptr->view_client = NULL;
}
- if (obj)
+ if (view_client)
{
- evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _e_pointer_cb_object_del, ptr);
- ptr->o_ptr = obj;
+ view = e_view_client_view_get(view_client);
+ ptr->destroy_listener.notify = _e_pointer_cb_view_del;
+ e_view_event_listener_add(view, E_VIEW_DESTROY, &ptr->destroy_listener);
+ ptr->view_client = view_client;
}
}
static void
_e_pointer_cb_free(E_Pointer *ptr)
{
- _e_pointer_object_set(ptr, NULL);
+ _e_pointer_view_set(ptr, NULL);
_ptrs = eina_list_remove(_ptrs, ptr);
}
static Eina_Bool
-_e_pointer_object_hide(E_Pointer *ptr, Evas_Object *obj)
+_e_pointer_view_hide(E_Pointer *ptr, E_View_Client *view_client)
{
E_Client *ec;
Eina_Bool res = EINA_FALSE;
- ec = e_comp_object_client_get(obj);
+ ec = e_view_data_get(&view_client->view, "E_Client");
if ((ec) && (!e_object_is_del(E_OBJECT(ec))))
{
ec->hidden = 1;
}
/* hide cursor object */
- if (evas_object_visible_get(obj))
+ if (e_view_client_visible_get(view_client))
{
res = EINA_TRUE;
- evas_object_hide(obj);
- evas_damage_rectangle_add(e_comp->evas, 0, 0, e_comp->w, e_comp->h);
+ e_view_hide(&view_client->view);
+ e_canvas_damage_rectangle_add(e_comp_canvas_get(), 0, 0, e_comp->w, e_comp->h);
}
- _e_pointer_object_set(ptr, NULL);
+ _e_pointer_view_set(ptr, NULL);
ptr->device = E_POINTER_NONE;
return res;
}
static Eina_Bool
-_e_pointer_object_show(E_Pointer *ptr, Evas_Object *obj)
+_e_pointer_view_show(E_Pointer *ptr, E_View_Client *view_client)
{
E_Client *ec;
Eina_Bool res = EINA_FALSE;
- ec = e_comp_object_client_get(obj);
+ ec = e_view_data_get(&view_client->view, "E_Client");
if (ec && e_pixmap_usable_get(ec->pixmap))
{
ec->hidden = 0;
ec->visible = EINA_TRUE;
e_client_visibility_set(ec, E_VISIBILITY_UNOBSCURED);
- evas_object_geometry_set(ec->frame, ec->x, ec->y, ec->w, ec->h);
+ e_view_client_geometry_set(e_client_view_get(ec), ec->x, ec->y, ec->w, ec->h);
+
ec->comp_data->mapped = EINA_TRUE;
ec->override = 0; /* do not ignore the cursor_ec to set the image object */
}
/* show cursor object */
- if (!evas_object_visible_get(obj))
+ if (!e_view_client_visible_get(view_client))
{
res = EINA_TRUE;
- evas_object_show(obj);
+ e_view_show(&view_client->view);
}
- _e_pointer_object_set(ptr, obj);
+ _e_pointer_view_set(ptr, view_client);
return res;
}
EINTERN void
-e_pointer_object_set(E_Pointer *ptr, Evas_Object *obj, int x, int y)
+e_pointer_view_set(E_Pointer *ptr, E_View_Client *view_client, int x, int y)
{
Eina_Bool need_call_hide = EINA_FALSE;
/* don't show cursor if in hidden mode */
if ((!e_config->show_cursor) || (!e_comp_wl->ptr.enabled))
{
- if (ptr->o_ptr && _e_pointer_object_hide(ptr, ptr->o_ptr))
+ if (ptr->view_client && _e_pointer_view_hide(ptr, ptr->view_client))
_e_pointer_hook_call(E_POINTER_HOOK_HIDE, ptr);
return;
}
/* hide and unset the existed ptr->o_ptr */
- if (ptr->o_ptr && (ptr->o_ptr != obj))
+ if (ptr->view_client && (ptr->view_client != view_client))
{
- if (_e_pointer_object_hide(ptr, ptr->o_ptr))
+ if (_e_pointer_view_hide(ptr, ptr->view_client))
need_call_hide = EINA_TRUE;
}
ptr->hot.y = y;
/* if obj is not null, set the obj to ptr->o_ptr */
- if (obj && (ptr->o_ptr != obj))
+ if (view_client && (ptr->view_client != view_client))
{
- if (_e_pointer_object_show(ptr, obj))
+ if (_e_pointer_view_show(ptr, view_client))
{
need_call_hide = EINA_FALSE;
_e_pointer_hook_call(E_POINTER_HOOK_SHOW, ptr);
EINTERN void
e_pointer_hide(E_Pointer *ptr)
{
+ E_View *view;
+
EINA_SAFETY_ON_NULL_RETURN(ptr);
- if (!ptr->o_ptr) return;
- if (!evas_object_visible_get(ptr->o_ptr)) return;
+ if (!ptr->view_client) return;
+
+ view = e_view_client_view_get(ptr->view_client);
+ if (!view) return;
+ if (!e_view_visible_get(view)) return;
- evas_object_hide(ptr->o_ptr);
+ e_view_hide(view);
}
E_API Eina_Bool
e_pointer_is_hidden(E_Pointer *ptr)
{
+ E_View *view;
+
EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_TRUE);
if (!e_config->show_cursor) return EINA_TRUE;
- if (ptr->o_ptr && evas_object_visible_get(ptr->o_ptr)) return EINA_FALSE;
+
+ if (ptr->view_client)
+ {
+ view = e_view_client_view_get(ptr->view_client);
+ if (e_view_visible_get(view)) return EINA_FALSE;
+ }
return EINA_TRUE;
}
EINTERN void
e_pointer_position_get(E_Pointer *ptr, int *x, int *y)
{
+ E_View *view;
+
EINA_SAFETY_ON_NULL_RETURN(ptr);
if (!e_config->show_cursor) return;
- if (!ptr->o_ptr) return;
- if (!evas_object_visible_get(ptr->o_ptr)) return;
+ if (!ptr->view_client) return;
+ view = e_view_client_view_get(ptr->view_client);
+ if (!e_view_visible_get(view)) return;
*x = ptr->x;
*y = ptr->y;
const Eina_List *l;
E_Pointer *ptr;
E_Client *ptr_ec = NULL;
+ E_View *view;
if ((!ec) || (e_object_is_del(E_OBJECT(ec)))) return NULL;
EINA_LIST_FOREACH(_ptrs, l, ptr)
{
- if (ptr->o_ptr)
+ if (ptr->view_client)
{
- ptr_ec = e_comp_object_client_get(ptr->o_ptr);
+ view = e_view_client_view_get(ptr->view_client);
+ ptr_ec = e_view_data_get(view, "E_Client");
if (ptr_ec == ec)
- return ptr;
+ return ptr;
}
}
#include "e_intern.h"
#include "e_pointer.h"
+#include "e_view_client_intern.h"
#define E_POINTER_TYPE 0xE0b01013
EINTERN int e_pointer_shutdown(void);
EINTERN E_Pointer *e_pointer_canvas_new(Ecore_Evas *ee, Eina_Bool filled);
-EINTERN void e_pointer_object_set(E_Pointer *ptr, Evas_Object *obj, int x, int y);
+EINTERN void e_pointer_view_set(E_Pointer *ptr, E_View_Client *view, int x, int y);
EINTERN void e_pointer_touch_move(E_Pointer *ptr, int x, int y);
EINTERN E_Pointer *e_pointer_get(E_Client *ec);
EINTERN void e_pointer_hide(E_Pointer *ptr);
#include "e_comp_wl_tbm_intern.h"
#include "e_presentation_time_intern.h"
#include "e_comp_object_intern.h"
-
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
E_Policy *e_policy = NULL;
Eina_Hash *hash_policy_desks = NULL;
_e_policy_client_dialog_policy_apply(E_Policy_Client *pc)
{
E_Client *ec;
+ E_View *view;
int x, y, w, h;
int zx, zy, zw, zh;
y = zy + ((zh - h) / 2);
if ((x != ec->x) || (y != ec->y))
- evas_object_move(ec->frame, x, y);
+ {
+ view = e_view_client_view_get(e_client_view_get(ec));
+ e_view_position_set(view, x, y);
+ }
}
static void
static void
_e_policy_cb_hook_client_eval_pre_new_client(void *d EINA_UNUSED, E_Client *ec)
{
- short ly;
+ E_View *view;
+ E_View_Client *view_client;
+ E_Canvas_Layer layer;
+ E_Layer ly;
if (e_object_is_del(E_OBJECT(ec))) return;
ec->placed = 1;
ec->exp_iconify.skip_iconify = EINA_TRUE;
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
if (ec->layer < E_LAYER_CLIENT_ABOVE)
e_client_layer_set(ec, E_LAYER_CLIENT_ABOVE);
}
+
+ view_client = e_client_view_get(ec);
if (e_policy_client_is_noti(ec))
{
- if (ec->frame)
+ if (view_client)
{
- ly = evas_object_layer_get(ec->frame);
+ view = e_view_client_view_get(view_client);
+ layer = e_view_layer_index_get(view);
+ ly = e_canvas_util_layer_map(layer);
ELOGF("NOTI", " |ec->layer:%d object->layer:%d", ec, ec->layer, ly);
if (ly != ec->layer)
e_client_layer_set(ec, ec->layer);
if (e_policy_client_is_dialog(ec))
{
- if (ec->frame && !ec->parent)
+ if (view_client && !ec->parent)
{
if (ec->layer != E_POLICY_DIALOG_LAYER)
e_client_layer_set(ec, E_POLICY_DIALOG_LAYER);
if (e_policy_client_is_floating(ec))
{
- if (ec->frame)
+ if (view_client)
{
if (ec->layer != E_LAYER_CLIENT_ABOVE)
e_client_layer_set(ec, E_LAYER_CLIENT_ABOVE);
if (e_policy_client_is_toast_popup(ec))
{
- if (ec->frame)
+ if (view_client)
{
if (ec->layer != E_POLICY_TOAST_POPUP_LAYER)
e_client_layer_set(ec, E_POLICY_TOAST_POPUP_LAYER);
Eina_Bool obscured_by_alpha_opaque = EINA_FALSE;
Eina_Bool find_above = EINA_FALSE;
E_Client *above_ec;
- Evas_Object *o;
+ E_View *view, *ec_view;
if (e_comp_client_zone_is_displaying(ec))
{
return;
}
- for (o = evas_object_above_get(ec->frame); o; o = evas_object_above_get(o))
+ ec_view = e_view_client_view_get(e_client_view_get(ec));
+ for (view = e_view_above_get(ec_view); view; view = e_view_above_get(view))
{
- above_ec = evas_object_data_get(o, "E_Client");
+ above_ec = e_view_data_get(view, "E_Client");
if (!above_ec) continue;
if (e_client_util_ignored_get(above_ec)) continue;
if (!above_ec->visible) continue;
if (above_ec->argb)
{
- if (above_ec->visibility.opaque != E_ALPHA_OPAQUE_SET)
+ if (above_ec->visibility.opaque <= E_ALPHA_OPAQUE_SET)
continue;
else
{
if ((e_pixmap_image_data_get(ec->pixmap)) &&
(!e_pixmap_dirty_get(ec->pixmap)))
{
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
}
}
}
E_Event_Client *ev;
E_Client *ec;
E_Policy_Client *pc;
+ E_View *view;
int zh = 0;
ev = (E_Event_Client *)event;
/* re-calculate window's position with changed size */
if (e_policy_client_is_volume_tv(ec))
{
+ view = e_view_client_view_get(e_client_view_get(ec));
e_zone_useful_geometry_get(pc->zone, NULL, NULL, NULL, &zh);
- evas_object_move(ec->frame, 0, (zh / 2) - (ec->h / 2));
-
- evas_object_pass_events_set(ec->frame, 1);
+ e_view_position_set(view, 0, (zh / 2) - (ec->h / 2));
+ e_view_pass_events_set(view, 1);
}
/* calculate e_client visibility */
if (send_event)
e_policy_wl_iconify_state_change_send(ec, 0);
- e_comp_object_effect_set(ec->frame, NULL);
+ e_view_client_effect_set(e_client_view_get(ec), NULL);
}
EINTERN Eina_Bool
}
/* composite object clear */
- e_comp_object_clear(ec->frame);
+ e_view_client_clear(e_client_view_get(ec));
/* pending frame event callback*/
if (!ec->comp_data) return;
#include "e_comp_wl_intern.h"
#include "e_config_intern.h"
#include "e_comp_object_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <wayland-server.h>
#include <tizen-extension-server-protocol.h>
E_Client_Hook *owner_del_hook;
} Defer_Job;
-
typedef struct
{
Conformant_Type type;
// comp_object listeners
struct wl_listener comp_object_hiding;
+
+ //view event
+ struct wl_listener del_listener;
+ struct wl_listener show_listener;
+ struct wl_listener hide_listener;
+ struct wl_listener move_listener;
+ struct wl_listener resize_listener;
} Conformant_Part;
typedef struct
/* checks for dectecting visible state changes */
if ((!part_ec->visible) || (part_ec->iconic) || (part_ec->hidden))
- evas_object_hide(part_ec->frame);
+ e_view_client_hide(e_client_view_get(part_ec));
}
}
else if (job->type == DEFER_JOB_RESIZE)
/* checks for dectecting visible state changes */
if ((!part_ec->visible) || (part_ec->iconic) || (part_ec->hidden))
- evas_object_hide(part_ec->frame);
+ e_view_client_hide(e_client_view_get(part_ec));
}
}
else if (job->type == DEFER_JOB_RESIZE)
}
static void
-_conf_cb_part_obj_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_conf_cb_part_del(struct wl_listener *listener, void *data)
{
- Conformant_Type type = (Conformant_Type)data;
+ Conformant_Part *conf_part;
+ Conformant_Type type;
Defer_Job *job;
if (!g_conf)
return;
+ conf_part = wl_container_of(listener, conf_part, del_listener);
+ type = conf_part->type;
+
DBG("PART %s ec(%p) Deleted", _conf_type_to_str(type), g_conf->part[type].ec);
g_conf->part[type].ec = NULL;
}
static void
-_conf_cb_part_obj_show(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_conf_cb_part_show(struct wl_listener *listener, void *data)
{
- Conformant_Type type = (Conformant_Type)data;
+ Conformant_Part *conf_part;
+ Conformant_Type type;
E_Client *owner = NULL;
if (!g_conf)
return;
+ conf_part = wl_container_of(listener, conf_part, show_listener);
+ type = conf_part->type;
+
DBG("PART %s win(%zx), ec(%p) Show", _conf_type_to_str(type), e_client_util_win_get(g_conf->part[type].ec), g_conf->part[type].ec);
owner = _conf_part_owner_find(g_conf->part[type].ec, type);
}
static void
-_conf_cb_part_obj_hide(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_conf_cb_part_hide(struct wl_listener *listener, void *data)
{
- Conformant_Type type = (Conformant_Type)data;
+ Conformant_Part *conf_part;
+ Conformant_Type type;
if (!g_conf)
return;
+ conf_part = wl_container_of(listener, conf_part, hide_listener);
+ type = conf_part->type;
+
DBG("PART %s win(%zx), ec(%p) Hide", _conf_type_to_str(type), e_client_util_win_get(g_conf->part[type].ec), g_conf->part[type].ec);
_conf_state_update(type,
EINA_FALSE,
}
static void
-_conf_part_cb_comp_object_hiding(struct wl_listener *listener, void *data)
+_conf_cb_part_move(struct wl_listener *listener, void *data)
{
Conformant_Part *conf_part;
+ Conformant_Type type;
- conf_part = wl_container_of(listener, conf_part, comp_object_hiding);
+ if (!g_conf)
+ return;
- DBG("PART %s win(%zx), ec(%p) Hiding",
- _conf_type_to_str(conf_part->type), e_client_util_win_get(conf_part->ec), conf_part->ec);
+ conf_part = wl_container_of(listener, conf_part, move_listener);
+ type = conf_part->type;
- _conf_state_update(conf_part->type,
- EINA_FALSE,
- conf_part->state.x,
- conf_part->state.y,
- conf_part->state.w,
- conf_part->state.h);
+ DBG("PART %s win(%zx), ec(%p) Move", _conf_type_to_str(type), e_client_util_win_get(g_conf->part[type].ec), g_conf->part[type].ec);
- conf_part->owner = NULL;
+ g_conf->part[type].changed = 1;
}
static void
-_conf_cb_part_obj_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_conf_cb_part_resize(struct wl_listener *listener, void *data)
{
- Conformant_Type type = (Conformant_Type)data;
+ Conformant_Part *conf_part;
+ Conformant_Type type;
if (!g_conf)
return;
- DBG("PART %s win(%zx), ec(%p) Move", _conf_type_to_str(type), e_client_util_win_get(g_conf->part[type].ec), g_conf->part[type].ec);
+ conf_part = wl_container_of(listener, conf_part, resize_listener);
+ type = conf_part->type;
+
+ DBG("PART %s win(%zx), ec(%p) Resize", _conf_type_to_str(type), e_client_util_win_get(g_conf->part[type].ec), g_conf->part[type].ec);
g_conf->part[type].changed = 1;
}
static void
-_conf_cb_part_obj_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_conf_part_cb_comp_object_hiding(struct wl_listener *listener, void *data)
{
- Conformant_Type type = (Conformant_Type)data;
+ Conformant_Part *conf_part;
- if (!g_conf)
- return;
+ conf_part = wl_container_of(listener, conf_part, comp_object_hiding);
- DBG("PART %s win(%zx), ec(%p) Resize", _conf_type_to_str(type), e_client_util_win_get(g_conf->part[type].ec), g_conf->part[type].ec);
+ DBG("PART %s win(%zx), ec(%p) Hiding",
+ _conf_type_to_str(conf_part->type), e_client_util_win_get(conf_part->ec), conf_part->ec);
- g_conf->part[type].changed = 1;
+ _conf_state_update(conf_part->type,
+ EINA_FALSE,
+ conf_part->state.x,
+ conf_part->state.y,
+ conf_part->state.w,
+ conf_part->state.h);
+
+ conf_part->owner = NULL;
}
static void
_conf_part_register(E_Client *ec, Conformant_Type type)
{
+ E_View *view;
+
if (!g_conf)
return;
g_conf->part[type].ec = ec;
g_conf->part[type].type = type;
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_DEL, _conf_cb_part_obj_del, (void*)type);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _conf_cb_part_obj_show, (void*)type);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _conf_cb_part_obj_hide, (void*)type);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _conf_cb_part_obj_move, (void*)type);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _conf_cb_part_obj_resize, (void*)type);
+ view = e_view_client_view_get(e_client_view_get(ec));
+ g_conf->part[type].del_listener.notify = _conf_cb_part_del;
+ e_view_destroy_listener_add(view, &g_conf->part[type].del_listener);
+
+ g_conf->part[type].show_listener.notify = _conf_cb_part_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &g_conf->part[type].show_listener);
+
+ g_conf->part[type].hide_listener.notify = _conf_cb_part_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &g_conf->part[type].hide_listener);
+
+ g_conf->part[type].move_listener.notify = _conf_cb_part_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &g_conf->part[type].move_listener);
+
+ g_conf->part[type].resize_listener.notify = _conf_cb_part_resize;
+ e_view_event_listener_add(view, E_VIEW_RESIZE, &g_conf->part[type].resize_listener);
g_conf->part[type].comp_object_hiding.notify = _conf_part_cb_comp_object_hiding;
- e_comp_object_hiding_listener_add(ec->frame, &g_conf->part[type].comp_object_hiding);
+ e_view_client_hide_listener_add(e_client_view_get(ec), &g_conf->part[type].comp_object_hiding);
}
static void
_conf_part_deregister(E_Client *ec, Conformant_Type type)
{
Defer_Job *job;
+ E_View *view;
if (!g_conf)
return;
wl_list_remove(&g_conf->part[type].comp_object_hiding.link);
// deregister callback
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_DEL, _conf_cb_part_obj_del, (void*)type);
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_SHOW, _conf_cb_part_obj_show, (void*)type);
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_HIDE, _conf_cb_part_obj_hide, (void*)type);
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_MOVE, _conf_cb_part_obj_move, (void*)type);
- evas_object_event_callback_del_full(ec->frame, EVAS_CALLBACK_RESIZE, _conf_cb_part_obj_resize, (void*)type);
+ view = e_view_client_view_get(e_client_view_get(ec));
+ wl_list_remove(&g_conf->part[type].del_listener.link);
+ e_view_event_listener_del(view, E_VIEW_SHOW, &g_conf->part[type].show_listener);
+ e_view_event_listener_del(view, E_VIEW_HIDE, &g_conf->part[type].hide_listener);
+ e_view_event_listener_del(view, E_VIEW_MOVE, &g_conf->part[type].move_listener);
+ e_view_event_listener_del(view, E_VIEW_RESIZE, &g_conf->part[type].resize_listener);
g_conf->part[type].type = CONFORMANT_TYPE_MAX;
g_conf->part[type].ec = NULL;
if (g_conf->part[type].ec)
{
E_Client *ec = g_conf->part[type].ec;
+ E_View *view = e_view_client_view_get(e_client_view_get(ec));
//wait for end of animation
- if ((e_comp_object_is_animating(ec->frame)) ||
- (evas_object_data_get(ec->frame, "effect_running")))
+ if (e_view_client_is_animating(e_client_view_get(ec)) ||
+ e_view_data_get(view, "effect_running"))
{
DBG("Animation is running, skip and try next ec(%p)", ec);
continue;
}
- visible = evas_object_visible_get(g_conf->part[type].ec->frame);
- evas_object_geometry_get(g_conf->part[type].ec->frame, &x, &y, &w, &h);
-
+ visible = e_view_client_visible_get(e_client_view_get(ec));
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, &w, &h);
}
_conf_state_update(type, visible, x, y, w, h);
g_conf->part[type].changed = EINA_FALSE;
#include "e_prefix_intern.h"
#include "e_theme_intern.h"
#include "e_config_intern.h"
+#include "e_comp_canvas_intern.h"
+#include "e_view_intern.h"
+#include "e_view_edje_intern.h"
-static void _e_policy_cb_softkey(void *data, Evas_Object *obj EINA_UNUSED, const char *emission, const char *source EINA_UNUSED);
+static void _e_policy_cb_softkey(void *data, E_View_Edje *edje, const char *emission, const char *source);
static void _e_policy_softkey_iconify(E_Zone *zone, Eina_Bool all);
-static Evas_Object *_e_policy_softkey_icon_add(E_Zone *zone, const char *name);
-static void _e_policy_softkey_icon_del(Evas_Object *comp_obj);
+static E_View_Edje *_e_policy_softkey_icon_add(E_Zone *zone, const char *name);
+static void _e_policy_softkey_icon_del(E_View_Edje *comp_edje);
static E_Policy_Softkey_Funcs *_e_softkey_funcs = NULL;
static void
-_e_policy_cb_softkey(void *data, Evas_Object *obj EINA_UNUSED, const char *emission, const char *source EINA_UNUSED)
+_e_policy_cb_softkey(void *data, E_View_Edje *edje, const char *emission, const char *source)
{
E_Zone *zone;
Eina_Bool all;
{
if (e_client_util_ignored_get(ec)) continue;
if (!e_desk_has_ec(desk, ec)) continue;
- if (!evas_object_visible_get(ec->frame)) continue;
+ if (!e_view_client_visible_get(e_client_view_get(ec))) continue;
if ((launcher) && (launcher->ec == ec))
return;
}
}
-static Evas_Object *
+static E_View_Edje *
_e_policy_softkey_icon_add(E_Zone *zone, const char *name)
{
- Evas_Object *obj, *comp_obj;
+ E_View_Edje *edje, *comp_edje;
char path[PATH_MAX], group[PATH_MAX];
- obj = edje_object_add(e_comp->evas);
+ edje = e_view_edje_create(e_canvas_layer_view_tree_get(e_comp_canvas_get(), E_CANVAS_LAYER_DESK_OBJECT_ABOVE));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(edje, NULL);
snprintf(group, sizeof(group), "e/modules/policy-mobile/softkey/%s", name);
e_prefix_data_snprintf(path, sizeof(path), "data/themes/%s", "e-policy.edj");
- if (!e_theme_edje_object_set(obj, NULL, group))
- edje_object_file_set(obj, path, group);
+ if (!e_theme_edje_view_set(edje, NULL, group))
+ e_view_edje_file_set(edje, path, group);
- edje_object_signal_callback_add(obj, "e,action,softkey,*", "e",
+ e_view_edje_signal_callback_add(edje, "e,action,softkey,*", "e",
_e_policy_cb_softkey, zone);
/* use TYPE_NONE to disable shadow for softkey object */
- comp_obj = e_comp_object_util_add(obj);
- evas_object_layer_set(comp_obj, E_LAYER_DESK_OBJECT_ABOVE);
+ comp_edje = e_view_edje_util_add(e_view_edje_view_get(edje));
+ e_view_data_set(e_view_edje_view_get(comp_edje), "policy_mobile_obj", edje);
- evas_object_data_set(comp_obj, "policy_mobile_obj", obj);
-
- return comp_obj;
+ return comp_edje;
}
static void
-_e_policy_softkey_icon_del(Evas_Object *comp_obj)
+_e_policy_softkey_icon_del(E_View_Edje *comp_edje)
{
- Evas_Object *obj;
-
- obj = evas_object_data_get(comp_obj, "policy_mobile_obj");
+ E_View_Edje *edje;
- edje_object_signal_callback_del(obj, "e,action,softkey,*",
+ edje = e_view_data_get(e_view_edje_view_get(comp_edje), "policy_mobile_obj");
+ e_view_edje_signal_callback_del(edje, "e,action,softkey,*",
"e", _e_policy_cb_softkey);
- evas_object_hide(comp_obj);
- evas_object_del(comp_obj);
+ e_view_hide(e_view_edje_view_get(comp_edje));
+ e_view_destroy(e_view_edje_view_get(comp_edje));
}
EINTERN E_Policy_Softkey *
e_policy_softkey_update(softkey);
- evas_object_show(softkey->home);
- evas_object_show(softkey->back);
+ e_view_show(e_view_edje_view_get(softkey->home));
+ e_view_show(e_view_edje_view_get(softkey->back));
}
EINTERN void
if (!softkey) return;
- evas_object_hide(softkey->home);
- evas_object_hide(softkey->back);
+ e_view_hide(e_view_edje_view_get(softkey->home));
+ e_view_hide(e_view_edje_view_get(softkey->back));
}
E_API void
y = h - oh;
space = ow * 4;
- evas_object_geometry_set(softkey->home, x - space, y, ow, oh);
- evas_object_geometry_set(softkey->back, x + space, y, ow, oh);
+ e_view_edje_geometry_set(softkey->home, x - space, y, ow, oh);
+ e_view_edje_geometry_set(softkey->back, x + space, y, ow, oh);
}
E_API int
if (!softkey) return 0;
- visible = evas_object_visible_get(softkey->home);
+ visible = e_view_visible_get(e_view_edje_view_get(softkey->home));
return visible;
}
e_policy_stack_below(E_Client *ec, E_Client *below_ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
EINA_SAFETY_ON_NULL_RETURN(below_ec);
- EINA_SAFETY_ON_NULL_RETURN(below_ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(below_ec));
e_client_stack_below(ec, below_ec);
}
e_policy_stack_above(E_Client *ec, E_Client *above_ec)
{
EINA_SAFETY_ON_NULL_RETURN(ec);
- EINA_SAFETY_ON_NULL_RETURN(ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(ec));
EINA_SAFETY_ON_NULL_RETURN(above_ec);
- EINA_SAFETY_ON_NULL_RETURN(above_ec->frame);
+ EINA_SAFETY_ON_NULL_RETURN(e_client_view_get(above_ec));
e_client_stack_above(ec, above_ec);
}
#include "e_client_intern.h"
#include "e_comp_object_intern.h"
#include "e_config_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#ifdef ENABLE_TTRACE
# include <ttrace.h>
_e_policy_check_above_alpha_opaque(E_Client *ec)
{
E_Client *above_ec;
- Evas_Object *o;
+ E_View *view;
Eina_Bool alpha_opaque = EINA_FALSE;
int ex, ey, ew, eh;
int ax, ay, aw, ah;
e_client_geometry_get(ec, &ex, &ey, &ew, &eh);
- for (o = evas_object_above_get(ec->frame); o; o = evas_object_above_get(o))
+ view = e_view_client_view_get(e_client_view_get(ec));
+ for (view = e_view_above_get(view); view; view = e_view_above_get(view))
{
- above_ec = evas_object_data_get(o, "E_Client");
+ above_ec = e_view_data_get(view, "E_Client");
if (!above_ec) continue;
if (e_client_util_ignored_get(above_ec)) continue;
if (above_ec->comp_data && !above_ec->comp_data->mapped) continue;
_e_policy_client_below_uniconify(E_Client *ec)
{
E_Client *below_ec;
- Evas_Object *o;
+ E_View *view;
- for (o = evas_object_below_get(ec->frame); o; o = evas_object_below_get(o))
+ view = e_view_client_view_get(e_client_view_get(ec));
+ for (view = e_view_below_get(view); view; view = e_view_below_get(view))
{
- below_ec = evas_object_data_get(o, "E_Client");
+ below_ec = e_view_data_get(view, "E_Client");
if (!below_ec) continue;
if (e_client_util_ignored_get(below_ec)) continue;
E_CLIENT_REVERSE_FOREACH(ec)
{
/* TODO: check if client is included to zone of mobile */
- if (!evas_object_visible_get(ec->frame)) continue;
+ if (!e_view_client_visible_get(e_client_view_get(ec))) continue;
pol_vis->fg_clients = eina_list_append(pol_vis->fg_clients, ec);
if (_e_vis_ec_activity_check(ec, EINA_TRUE, EINA_TRUE))
/* force update
* NOTE: this update can invoke some functions related to visibility grab */
/* if comp_object is not redirected, the compositor doesn't want to update it */
- if (e_comp_object_redirected_get(ec->frame))
+ if (e_view_client_redirected_get(e_client_view_get(ec)))
{
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
}
l = eina_list_clone(vc->wait_buf_attach_grab_list);
}
static void
-_e_vis_client_cb_evas_show(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_vis_client_cb_show(struct wl_listener *listener, void *data)
{
- OBJ_EC_GET(ec, obj);
+ E_Client *ec;
+
+ ec = wl_container_of(listener, ec, visibility.show_listener);
+
VS_DBG(ec, "CALLBACK 'SHOW'...");
_e_vis_update_foreground_job_queue();
E_VIS_CLIENT_GET_OR_RETURN(vc, ec);
}
static void
-_e_vis_client_cb_evas_hide(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_vis_client_cb_hide(struct wl_listener *listener, void *data)
{
- OBJ_EC_GET(ec, obj);
+ E_Client *ec;
+
+ ec = wl_container_of(listener, ec, visibility.hide_listener);
+
VS_DBG(ec, "CALLBACK 'HIDE'...");
_e_vis_update_foreground_job_queue();
E_VIS_CLIENT_GET_OR_RETURN(vc, ec);
}
static void
-_e_vis_client_cb_evas_move(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_vis_client_cb_move(struct wl_listener *listener, void *data)
{
Evas_Coord x, y;
Eina_Bool visible;
+ E_Client *ec;
+ E_View_Client *view_client;
+
+ ec = wl_container_of(listener, ec, visibility.move_listener);
+ view_client = e_client_view_get(ec);
- OBJ_EC_GET(ec, obj);
- evas_object_geometry_get(obj, &x, &y, NULL, NULL);
- visible = evas_object_visible_get(obj);
+ e_view_client_geometry_get(view_client, &x, &y, NULL, NULL);
+ visible = e_view_client_visible_get(view_client);
VS_DBG(ec, "CALLBACK 'MOVE'... %d %d (v %d)", x, y, visible);
if (visible) _e_vis_update_foreground_job_queue();
}
static void
-_e_vis_client_cb_evas_resize(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+_e_vis_client_cb_resize(struct wl_listener *listener, void *data)
{
Evas_Coord w, h;
Eina_Bool visible;
+ E_Client *ec;
+ E_View_Client *view_client;
+
+ ec = wl_container_of(listener, ec, visibility.resize_listener);
+ view_client = e_client_view_get(ec);
+
+ e_view_client_geometry_get(view_client, NULL, NULL, &w, &h);
+ visible = e_view_client_visible_get(view_client);
- OBJ_EC_GET(ec, obj);
- evas_object_geometry_get(obj, NULL, NULL, &w, &h);
- visible = evas_object_visible_get(obj);
VS_DBG(ec, "CALLBACK 'RESIZE'... %d %d (v %d)", w, h, visible);
if (visible) _e_vis_update_foreground_job_queue();
}
static void
-_e_vis_client_cb_evas_restack(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+_e_vis_client_cb_restack(struct wl_listener *listener, void *data)
{
Eina_Bool visible;
+ E_Client *ec;
+ E_View_Client *view_client;
- OBJ_EC_GET(ec, obj);
- visible = evas_object_visible_get(obj);
+ ec = wl_container_of(listener, ec, visibility.restack_listener);
+ view_client = e_client_view_get(ec);
+
+ visible = e_view_client_visible_get(view_client);
VS_DBG(ec, "CALLBACK 'RESTACK'... v %d", visible);
if (visible) _e_vis_update_foreground_job_queue();
}
/* check deleted client */
if (e_object_is_del(E_OBJECT(ec))) return EINA_FALSE;
/* check launchscreen */
- if (ec->frame) type = e_comp_object_content_type_get(ec->frame);
+ if (e_client_view_get(ec)) type = e_view_client_content_type_get(e_client_view_get(ec));
if ((type == E_COMP_OBJECT_CONTENT_TYPE_EXT_IMAGE) ||
(type == E_COMP_OBJECT_CONTENT_TYPE_EXT_EDJE))
check_mapped = 0;
_e_vis_client_job_exec_by_type(E_Vis_Client *vc, E_Vis_Job_Type type)
{
E_Client *ec = vc->ec;
+ int w, h;
VS_INF(ec, "Job Run: type %d", type);
e_client_lower(ec);
break;
case E_VIS_JOB_TYPE_HIDE:
- evas_object_hide(ec->frame);
+ e_view_client_hide(e_client_view_get(ec));
break;
case E_VIS_JOB_TYPE_LAYER_LOWER:
e_client_layer_set(ec, vc->layer);
if ((!e_object_is_del(E_OBJECT(ec))) &&
(ec->visible) && (!ec->hidden) &&
(!ec->iconic) && (!ec->ignored))
- evas_object_show(ec->frame);
+ e_view_client_show(e_client_view_get(ec));
if (vc->wait_for_child)
{
if ((!e_object_is_del(E_OBJECT(ec))) &&
(ec->visible) && (!ec->hidden) &&
(!ec->iconic) && (!ec->ignored))
- evas_object_move(ec->frame, ec->x, ec->y);
+ {
+ e_view_client_geometry_get(e_client_view_get(ec), NULL, NULL, &w, &h);
+ e_view_client_geometry_set(e_client_view_get(ec), ec->x, ec->y, w, h);
+ }
break;
default:
_e_vis_ec_above_visible_type(E_Client *ec, Eina_Bool check_child)
{
E_Client *above;
+ E_View *view;
E_Pol_Vis_Type above_vis_type = E_POL_VIS_TYPE_ALPHA;
int ex, ey, ew, eh;
int ax, ay, aw, ah;
for (above = e_client_above_get(ec); above; above = e_client_above_get(above))
{
if (e_client_util_ignored_get(above)) continue;
- if (above->frame && evas_object_data_get(above->frame, "comp_skip")) continue;
+ view = e_view_client_view_get(e_client_view_get(above));
+ if (e_view_data_get(view, "comp_skip")) continue;
if (check_child && (above->parent == ec)) continue;
if (above->first_mapped)
{
if (!below->internal)
*below_list = eina_list_prepend(*below_list, vc);
-
if (!(below->argb) || !(below->visibility.opaque != E_ALPHA_OPAQUE_SET))
{
eina_tiler_union(above_tile, below_tile);
static void
_e_vis_ec_setup(E_Client *ec)
{
+ E_View *view;
+
e_object_delay_del_set(E_OBJECT(ec), _e_vis_client_delay_del);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _e_vis_client_cb_evas_show, NULL);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _e_vis_client_cb_evas_hide, NULL);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_vis_client_cb_evas_move, NULL);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _e_vis_client_cb_evas_resize, NULL);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESTACK, _e_vis_client_cb_evas_restack, NULL);
+
+ view = e_view_client_view_get(e_client_view_get(ec));
+ ec->visibility.show_listener.notify = _e_vis_client_cb_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &ec->visibility.show_listener);
+
+ ec->visibility.hide_listener.notify = _e_vis_client_cb_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &ec->visibility.hide_listener);
+
+ ec->visibility.move_listener.notify = _e_vis_client_cb_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &ec->visibility.move_listener);
+
+ ec->visibility.resize_listener.notify = _e_vis_client_cb_resize;
+ e_view_event_listener_add(view, E_VIEW_RESIZE, &ec->visibility.resize_listener);
+
+ ec->visibility.restack_listener.notify = _e_vis_client_cb_restack;
+ e_view_event_listener_add(view, E_VIEW_RESTACK, &ec->visibility.restack_listener);
}
static void
_e_vis_ec_reset(E_Client *ec)
{
+ E_View *view;
+
e_object_delay_del_set(E_OBJECT(ec), NULL);
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_SHOW, _e_vis_client_cb_evas_show);
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_HIDE, _e_vis_client_cb_evas_hide);
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_MOVE, _e_vis_client_cb_evas_move);
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_RESIZE, _e_vis_client_cb_evas_resize);
- evas_object_event_callback_del(ec->frame, EVAS_CALLBACK_RESTACK, _e_vis_client_cb_evas_restack);
+
+ view = e_view_client_view_get(e_client_view_get(ec));
+ e_view_event_listener_del(view, E_VIEW_SHOW, &ec->visibility.show_listener);
+ e_view_event_listener_del(view, E_VIEW_HIDE, &ec->visibility.hide_listener);
+ e_view_event_listener_del(view, E_VIEW_MOVE, &ec->visibility.move_listener);
+ e_view_event_listener_del(view, E_VIEW_RESIZE, &ec->visibility.resize_listener);
+ e_view_event_listener_del(view, E_VIEW_RESTACK, &ec->visibility.restack_listener);
}
static void
#include "services/e_service_cbhm_intern.h"
#include "e_policy_conformant.h"
#include "e_policy_wl_intern.h"
+#include "e_view_client_intern.h"
typedef struct _E_Policy_Cbhm E_Policy_Cbhm;
Eina_List *hooks;
Eina_List *intercept_hooks;
Eina_List *events;
+
+ struct wl_listener show_listener;
};
static E_Policy_Cbhm *_pol_cbhm = NULL;
static void
_cbhm_free(E_Policy_Cbhm *cbhm)
{
+ E_View_Client *view_client = e_client_view_get(cbhm->ec);
+
+ if (view_client)
+ {
+ e_view_event_listener_del(e_view_client_view_get(view_client), E_VIEW_SHOW, &cbhm->show_listener);
+ cbhm->show_listener.notify = NULL;
+ }
+
E_FREE_LIST(cbhm->events, ecore_event_handler_del);
E_FREE_LIST(cbhm->hooks, e_client_hook_del);
E_FREE_LIST(cbhm->intercept_hooks, e_comp_object_intercept_hook_del);
}
static void
-_cbhm_cb_evas_show(void *d, Evas *evas EINA_UNUSED, Evas_Object *obj, void *event)
+_cbhm_cb_show(struct wl_listener *listener, void *data)
{
E_Policy_Cbhm *cbhm;
E_Client *ec;
E_Comp_Wl_Client_Data *cdata;
- cbhm = d;
+ cbhm = wl_container_of(listener, cbhm, show_listener);
if (EINA_UNLIKELY(!cbhm))
return;
if (EINA_UNLIKELY(!ec))
return;
- if (ec->frame != obj)
- return;
-
cdata = e_client_cdata_get(ec);
if ((!cbhm->show_block) && (cdata->mapped))
cbhm->show_block = EINA_TRUE;
{
E_Client *ec;
E_Zone *zone;
+ E_View_Client *view_client;
Eina_Bool cur_vis = EINA_FALSE;
int x, y, w, h;
ec = cbhm->ec;
zone = cbhm->zone;
- evas_object_geometry_get(ec->frame, &x, &y, &w, &h);
+ view_client = e_client_view_get(ec);
+ if (!view_client)
+ {
+ ELOGFE("CBHM", "view client is not exist in E_Client", ec);
+ return;
+ }
+
+ e_view_client_geometry_get(view_client, &x, &y, &w, &h);
if (E_INTERSECTS(x, y, w, h, zone->x, zone->y, zone->w, zone->h))
- cur_vis = evas_object_visible_get(ec->frame);
+ cur_vis = e_view_client_visible_get(view_client);
if (cur_vis == vis)
return;
}
else
{
+ E_View *view = e_view_client_view_get(view_client);
ec->visible = EINA_TRUE;
- evas_object_show(ec->frame);
+ e_view_show(view);
e_client_raise(ec);
}
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(view_client, 0, 0, ec->w, ec->h);
+ e_view_client_dirty(view_client);
+ e_view_client_render(view_client);
}
else
{
{
E_Policy_Cbhm *cbhm;
E_Comp_Wl_Client_Data *cdata;
+ E_View_Client *view_client;
if (EINA_UNLIKELY(!ec))
{
/* check for wayland pixmap */
if (e_pixmap_type_get(ec->pixmap) != E_PIXMAP_TYPE_WL) return;
- /* if we have not setup evas callbacks for this client, do it */
+ /* if we have not setup callbacks for this client, do it */
if (_pol_cbhm)
{
ERR("A CBHM Client already exists ec(%p)", _pol_cbhm->ec);
e_client_window_role_set(ec, "cbhm");
e_policy_conformant_part_add(ec);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _cbhm_cb_evas_show, cbhm);
+ view_client = e_client_view_get(ec);
+ if (view_client)
+ {
+ E_View *view = e_view_client_view_get(view_client);
+ cbhm->show_listener.notify = _cbhm_cb_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &cbhm->show_listener);
+ }
+
E_CLIENT_HOOK_APPEND(cbhm->hooks, E_CLIENT_HOOK_DEL, _cbhm_hook_client_del, cbhm);
E_LIST_HANDLER_APPEND(cbhm->events, E_EVENT_CLIENT_ZONE_SET, _cbhm_cb_client_zone_set, cbhm);
E_COMP_OBJECT_INTERCEPT_HOOK_APPEND(cbhm->intercept_hooks, E_COMP_OBJECT_INTERCEPT_HOOK_SHOW_HELPER, _cbhm_intercept_hook_show, cbhm);
#include "e_comp_wl_intern.h"
#include "e_dnd_intern.h"
#include "e_policy_private_data.h"
+#include "e_view_client_intern.h"
#include <wayland-server.h>
#include <tzsh_server.h>
EINA_ITERATOR_FOREACH(it, esk)
{
// Workaround: Feed mouse out/in to make sure that the mouse in to correct client.
- // The evas event mouse in/out is not emit during dragging(mouse move with mouse button pressed).
+ // The event mouse in/out is not emit during dragging(mouse move with mouse button pressed).
// It makes the pointer still locked after mouse out from kvm window When the drag started.
source = e_comp_wl->drag_source;
source_client = wl_resource_get_client(source->resource);
e_service_kvm_transparent_set(E_Service_Kvm *esk, Eina_Bool set)
{
E_Client *ec;
+ E_View *view;
EINA_SAFETY_ON_NULL_RETURN_VAL(esk, EINA_FALSE);
ELOGF("KVM", "set KVM service(%p) client to %s", ec, esk, set? "transparent" : "opaque");
+ if (!e_client_view_get(ec))
+ {
+ ELOGF("KVM", "ERROR... view_client for ec doesn't exist.", ec);
+ return EINA_FALSE;
+ }
+
+ view = e_view_client_view_get(e_client_view_get(ec));
+
if (set)
- evas_object_color_set(ec->frame, 0, 0, 0, 0);
+ e_view_color_set(view, 0, 0, 0, 0);
else
- evas_object_color_set(ec->frame, 255, 255, 255, 255);
+ e_view_color_set(view, 255, 255, 255, 255);
return EINA_TRUE;
}
#include "e_comp_object_intern.h"
#include "e_utils_intern.h"
#include "e_appinfo_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <tzsh_server.h>
#include <wayland-tbm-server.h>
_launcher_launched_ec_set(lc, target_ec);
//show target_ec
- e_comp_object_damage(target_ec->frame, 0, 0, target_ec->w, target_ec->h);
- e_comp_object_dirty(target_ec->frame);
- e_comp_object_render(target_ec->frame);
- evas_object_show(target_ec->frame);
+ e_view_client_damage(e_client_view_get(target_ec), 0, 0, target_ec->w, target_ec->h);
+ e_view_client_dirty(e_client_view_get(target_ec));
+ e_view_client_render(e_client_view_get(target_ec));
+ e_view_client_show(e_client_view_get(target_ec));
e_comp_client_override_del(target_ec);
}
{
E_Comp_Wl_Client_Data *target_cdata = e_client_cdata_get(target_ec);
ELOGF("LAUNCH", "SHOW real win (target->frame:%p, map:%d) by launcher service (win:0x%08zx, ec:%p).", target_ec, target_ec->frame, target_cdata->mapped, e_client_util_win_get(lc->ec), lc->ec);
- e_comp_object_signal_emit(target_ec->frame, "e,action,launch_real,done", "e");
+ e_view_client_signal_emit(e_client_view_get(target_ec), "e,action,launch_real,done", "e");
}
e_comp_object_signal_emit(target_ec->frame, "e,action,launch,done", "e");
}
/* check remote surface provider */
if (!prov_ec->remote_surface.provider) continue;
if (prov_ec->visible) continue;
- if (evas_object_visible_get(prov_ec->frame)) continue;
+ if (e_view_client_visible_get(e_client_view_get(prov_ec))) continue;
prov_cdata = e_client_cdata_get(prov_ec);
if (prov_cdata->mapped) continue;
if (!(lc = _launcher_handler_launcher_find(prov_ec))) continue;
#include "e_client_intern.h"
#include "e_comp_object_intern.h"
#include "e_layout_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#define SMART_NAME "quickpanel_object"
#define INTERNAL_ENTRY \
{ \
qp->show_block = EINA_FALSE; \
qp->ec->visible = EINA_TRUE; \
- evas_object_show(qp->ec->frame); \
+ e_view_client_show(e_client_view_get(qp->ec)); \
\
if (qp->bg_rect) \
{ \
{ \
qp->show_block = EINA_TRUE; \
qp->ec->visible = EINA_FALSE; \
- evas_object_hide(qp->ec->frame); \
+ e_view_client_hide(e_client_view_get(qp->ec)); \
\
if (qp->bg_rect) \
{ \
} geom;
E_Client *gesture_target;
+
+ // view listener
+ struct wl_listener show_listener;
+ struct wl_listener hide_listener;
+ struct wl_listener move_listener;
};
struct _Mover_Data
static Eina_Bool _e_qp_client_scrollable_state_set(E_Client *ec, E_Quickpanel_Type type, E_Quickpanel_Client_Scroll_State state);
static E_Quickpanel_Client_Scroll_State _e_qp_client_scrollable_state_get(E_Client *ec, E_Quickpanel_Type type);
-static void _quickpanel_client_evas_cb_show(void *data, Evas *evas, Evas_Object *obj, void *event);
-static void _quickpanel_client_evas_cb_hide(void *data, Evas *evas, Evas_Object *obj, void *event);
-static void _quickpanel_client_evas_cb_move(void *data, Evas *evas, Evas_Object *obj, void *event);
-
static Eina_Bool _quickpanel_check_skip_client(E_Client *ec);
inline static Eina_Bool
ec = md->ec;
/* force update */
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
// desk-zoom-set apply map on all e_desk's smart_data(clients)
// to properly pack a quickpanel window on the mover's e_layout_object
if (md->qp_layout_obj) evas_object_del(md->qp_layout_obj);
- evas_object_color_set(ec->frame, ec->netwm.opacity, ec->netwm.opacity, ec->netwm.opacity, ec->netwm.opacity);
+ e_view_color_set(e_view_client_view_get(e_client_view_get(ec)), ec->netwm.opacity, ec->netwm.opacity, ec->netwm.opacity, ec->netwm.opacity);
e_comp_client_override_del(ec);
* we need to force update 'E_Client' here even if update only evas_object,
* because our render loop would not be started by chaning evas object,
* we need to make a change on the 'E_Client'. */
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
e_layout_unpack(ec->frame);
{
if ((!qp->ec->focused) &&
(qp->ec->icccm.accepts_focus || qp->ec->icccm.take_focus) &&
- (evas_object_visible_get(qp->ec->frame) == EINA_TRUE))
+ (e_view_client_visible_get(e_client_view_get(qp->ec)) == EINA_TRUE))
{
ELOGF("QUICKPANEL", "effect finished but not focused. focus set to quickpanel", qp->ec);
e_client_focus_latest_set(qp->ec);
if ((qp->ec) &&
(!qp->ec->focused) &&
(qp->ec->icccm.accepts_focus || qp->ec->icccm.take_focus) &&
- (evas_object_visible_get(qp->ec->frame) == EINA_TRUE))
+ (e_view_client_visible_get(e_client_view_get(qp->ec)) == EINA_TRUE))
{
ELOGF("QUICKPANEL", "effect finished but not focused. focus set to quickpanel", qp->ec);
e_client_focus_latest_set(qp->ec);
{
ELOGF("QUICKPANEL", "Remove Client | qp %p", qp->ec, qp);
- evas_object_event_callback_del(qp->ec->frame, EVAS_CALLBACK_SHOW, _quickpanel_client_evas_cb_show);
- evas_object_event_callback_del(qp->ec->frame, EVAS_CALLBACK_HIDE, _quickpanel_client_evas_cb_hide);
- evas_object_event_callback_del(qp->ec->frame, EVAS_CALLBACK_MOVE, _quickpanel_client_evas_cb_move);
+ wl_list_remove(&qp->show_listener.link);
+ wl_list_remove(&qp->hide_listener.link);
+ wl_list_remove(&qp->move_listener.link);
if (qp->bg_rect)
evas_object_del(qp->bg_rect);
_quickpanel_free(qp);
}
-static void
-_quickpanel_client_evas_cb_show(void *data, Evas *evas, Evas_Object *obj, void *event)
-{
- E_Policy_Quickpanel *qp;
- E_Client *ec;
-
- qp = data;
- if (EINA_UNLIKELY(!qp))
- return;
-
- evas_object_show(qp->handler_obj);
- evas_object_raise(qp->handler_obj);
- evas_object_hide(qp->indi_obj);
-
- ec = qp->ec;
- if (ec)
- e_policy_client_buffer_flush_cancel(ec);
-
- E_FREE_FUNC(qp->buf_change_hdlr, ecore_event_handler_del);
-}
-
static Eina_Bool
_quickpanel_cb_buffer_change(void *data, int type, void *event)
{
goto end;
/* render forcibly */
- e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
- e_comp_object_dirty(ec->frame);
- e_comp_object_render(ec->frame);
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
/* make frame event */
e_pixmap_image_clear(ec->pixmap, EINA_TRUE);
/* use single buffer if qp service's ec is invisible */
- evas_object_geometry_get(ec->frame, &x, &y, &w, &h);
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, &w, &h);
if (E_INTERSECTS(x, y, w, h,
qp->zone->x,
qp->zone->y,
qp->zone->w,
qp->zone->h))
- vis = evas_object_visible_get(ec->frame);
+ vis = e_view_client_visible_get(e_client_view_get(ec));
if (!vis)
e_pixmap_buffer_clear(ec->pixmap, EINA_TRUE);
}
static void
-_quickpanel_client_evas_cb_hide(void *data, Evas *evas, Evas_Object *obj, void *event)
+_quickpanel_client_view_cb_show(struct wl_listener *listener, void *data)
{
E_Policy_Quickpanel *qp;
+ E_Client *ec;
- qp = data;
+ qp = wl_container_of(listener, qp, show_listener);
+ if (EINA_UNLIKELY(!qp))
+ return;
+
+ evas_object_show(qp->handler_obj);
+ evas_object_raise(qp->handler_obj);
+ evas_object_hide(qp->indi_obj);
+
+ ec = qp->ec;
+ if (ec)
+ e_policy_client_buffer_flush_cancel(ec);
+
+ E_FREE_FUNC(qp->buf_change_hdlr, ecore_event_handler_del);
+}
+
+static void
+_quickpanel_client_view_cb_hide(struct wl_listener *listener, void *data)
+{
+ E_Policy_Quickpanel *qp;
+
+ qp = wl_container_of(listener, qp, hide_listener);
if (EINA_UNLIKELY(!qp))
return;
}
static void
-_quickpanel_client_evas_cb_move(void *data, Evas *evas, Evas_Object *obj, void *event)
+_quickpanel_client_view_cb_move(struct wl_listener *listener, void *data)
{
E_Policy_Quickpanel *qp;
+ E_Client *ec;
int x, y, hx, hy;
- qp = data;
+ qp = wl_container_of(listener, qp, move_listener);
if (EINA_UNLIKELY(!qp))
return;
e_service_region_rectangle_get(qp->handler_obj, qp->rotation, &hx, &hy, NULL, NULL);
- evas_object_geometry_get(obj, &x, &y, NULL, NULL);
- evas_object_move(qp->handler_obj, x + hx, y + hy);
+ ec = qp->ec;
+ if (ec)
+ {
+ e_view_client_geometry_get(e_client_view_get(ec), &x, &y, NULL, NULL);
+ evas_object_move(qp->handler_obj, x + hx, y + hy);
+ }
}
static void
/* Add handler object to smart member to follow the client's stack */
evas_object_smart_member_add(obj, ec->frame);
evas_object_propagate_events_set(obj, 0);
- if (evas_object_visible_get(ec->frame))
+ if (e_view_client_visible_get(e_client_view_get(ec)))
evas_object_show(obj);
qp->handler_obj = obj;
qp->rotation = e_policy_angle_map(ec->e.state.rot.ang.curr);
- vis = evas_object_visible_get(ec->frame);
+ vis = e_view_client_visible_get(e_client_view_get(ec));
switch (qp->rotation)
{
case E_POLICY_ANGLE_MAP_90:
DBG("Stacking Client '%s'(%p)",
ev->ec->icccm.name ? ev->ec->icccm.name : "", ev->ec);
- if (evas_object_visible_get(ev->ec->frame))
+ if (e_view_client_visible_get(e_client_view_get(ev->ec)))
_quickpanel_below_change_eval(data, event);
end:
return ECORE_CALLBACK_PASS_ON;
_quickpanel_handler_obj_region_convert_set(qp, angle, x, y, w, h, ev->desk->geom.x, ev->desk->geom.y, ev->desk->geom.w, ev->desk->geom.h);
}
- evas_object_move(qp->ec->frame, ev->desk->geom.x, ev->desk->geom.y);
+ e_view_position_set(e_view_client_view_get(e_client_view_get(qp->ec)), ev->desk->geom.x, ev->desk->geom.y);
end:
return ECORE_CALLBACK_PASS_ON;
E_Policy_Quickpanel *qp = NULL;
E_Layer layer;
E_Zone *zone;
+ E_View *view;
BACKEND_FUNC_CALL(quickpanel_client_add, ec, type);
QP_HIDE(qp);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _quickpanel_client_evas_cb_show, qp);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _quickpanel_client_evas_cb_hide, qp);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _quickpanel_client_evas_cb_move, qp);
+ view = e_view_client_view_get(e_client_view_get(ec));
+ qp->show_listener.notify = _quickpanel_client_view_cb_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &qp->show_listener);
+ qp->hide_listener.notify = _quickpanel_client_view_cb_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &qp->hide_listener);
+ qp->move_listener.notify = _quickpanel_client_view_cb_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &qp->move_listener);
+
E_CLIENT_HOOK_APPEND(qp->hooks, E_CLIENT_HOOK_DEL, _quickpanel_hook_client_del, qp);
E_LIST_HANDLER_APPEND(qp->events, E_EVENT_CLIENT_ROTATION_CHANGE_BEGIN, _quickpanel_cb_rotation_begin, qp);
E_LIST_HANDLER_APPEND(qp->events, E_EVENT_CLIENT_ROTATION_CHANGE_CANCEL, _quickpanel_cb_rotation_cancel, qp);
if (!ec) continue;
if (e_object_is_del(E_OBJECT(ec))) continue;
- evas_object_geometry_get(ec->frame,
- &x, &y, &w, &h);
+ e_view_client_geometry_get(e_client_view_get(ec),
+ &x, &y, &w, &h);
if (E_INTERSECTS(x, y, w, h,
qp->zone->x,
qp->zone->w,
qp->zone->h))
{
- vis = evas_object_visible_get(ec->frame);
+ vis = e_view_client_visible_get(e_client_view_get(ec));
if (vis) return EINA_TRUE;
}
}
EINA_SAFETY_ON_NULL_RETURN_VAL(qp, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(qp->ec, EINA_FALSE);
- evas_object_geometry_get(qp->ec->frame, &x, &y, &w, &h);
+ e_view_client_geometry_get(e_client_view_get(qp->ec), &x, &y, &w, &h);
if (E_INTERSECTS(x, y, w, h, qp->zone->x, qp->zone->y, qp->zone->w, qp->zone->h))
- vis = evas_object_visible_get(qp->ec->frame);
+ vis = e_view_client_visible_get(e_client_view_get(qp->ec));
return vis;
}
#include "services/e_service_region_intern.h"
#include "e_policy_intern.h"
#include "e_policy_private_data.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <tzsh_server.h>
{ \
softkey_service->show_block = EINA_FALSE; \
softkey_service->ec->visible = EINA_TRUE; \
- evas_object_show(softkey_service->ec->frame); \
+ e_view_client_show(e_client_view_get(softkey_service->ec)); \
} \
} while (0)
{ \
softkey_service->show_block = EINA_TRUE; \
softkey_service->ec->visible = EINA_FALSE; \
- evas_object_hide(softkey_service->ec->frame); \
+ e_view_client_hide(e_client_view_get(softkey_service->ec)); \
} \
} while (0)
return EINA_TRUE;
}
-
static void
-_e_service_softkey_client_evas_cb_show(void *data, Evas *evas, Evas_Object *obj, void *event)
+_e_service_softkey_client_view_cb_show(struct wl_listener *listener, void *data)
{
E_Service_Softkey *softkey_service;
- softkey_service = data;
+ softkey_service = wl_container_of(listener, softkey_service, show_listener);
if (!softkey_service) return;
ELOGF("SOFTKEY", "Show SOFTKEY SERVICE(%p)!!! HIDE handler_obj (%p)...", NULL, softkey_service, softkey_service->handler_obj);
}
static void
-_e_service_softkey_client_evas_cb_hide(void *data, Evas *evas, Evas_Object *obj, void *event)
+_e_service_softkey_client_view_cb_hide(struct wl_listener *listener, void *data)
{
E_Service_Softkey *softkey_service;
- softkey_service = data;
+ softkey_service = wl_container_of(listener, softkey_service, hide_listener);
if (!softkey_service) return;
ELOGF("SOFTKEY", "Hide SOFTKEY SERVICE(%p)!!! SHOW handler_obj (%p)...", NULL, softkey_service, softkey_service->handler_obj);
E_Service_Softkey *softkey_service;
E_Zone *zone;
+ E_View *view;
if (_e_softkey_service_funcs && _e_softkey_service_funcs->softkey_service_client_set)
{
E_COMP_OBJECT_INTERCEPT_HOOK_APPEND(softkey_service->intercept_hooks, E_COMP_OBJECT_INTERCEPT_HOOK_SHOW_HELPER, _softkey_intercept_hook_show, softkey_service);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _e_service_softkey_client_evas_cb_show, softkey_service);
- evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _e_service_softkey_client_evas_cb_hide, softkey_service);
+ view = e_view_client_view_get(e_client_view_get(ec));
+ softkey_service->show_listener.notify = _e_service_softkey_client_view_cb_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &softkey_service->show_listener);
+ softkey_service->hide_listener.notify = _e_service_softkey_client_view_cb_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &softkey_service->hide_listener);
E_LIST_HANDLER_APPEND(softkey_service->events, E_EVENT_CLIENT_ZONE_SET, _softkey_service_cb_client_zone_set, softkey_service);
}
if (!softkey_service) return;
E_FREE_LIST(softkey_service->events, ecore_event_handler_del);
- evas_object_event_callback_del(softkey_service->ec->frame, EVAS_CALLBACK_SHOW, _e_service_softkey_client_evas_cb_show);
- evas_object_event_callback_del(softkey_service->ec->frame, EVAS_CALLBACK_HIDE, _e_service_softkey_client_evas_cb_hide);
+ wl_list_remove(&softkey_service->show_listener.link);
+ wl_list_remove(&softkey_service->hide_listener.link);
e_service_softkey_del(softkey_service);
}
if (!softkey_service) return 0;
if (!softkey_service->ec) return 0;
- visible = evas_object_visible_get(softkey_service->ec->frame);
+ visible = e_view_client_visible_get(e_client_view_get(softkey_service->ec));
return visible;
}
#include "services/e_service_volume_intern.h"
#include "e_policy_private_data.h"
#include "e_client_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
#include <wayland-server.h>
#include <tzsh_server.h>
#define REGION_OBJS_SHOW() REGION_OBJS_VISIBLE_CHANGE(EINA_TRUE)
#define REGION_OBJS_HIDE() REGION_OBJS_VISIBLE_CHANGE(EINA_FALSE)
+typedef struct _E_Service_Volume_Listener E_Service_Volume_Listener;
+struct _E_Service_Volume_Listener
+{
+ // view listener
+ struct wl_listener show_listener;
+ struct wl_listener hide_listener;
+ struct wl_listener move_listener;
+ struct wl_listener restack_listener;
+};
+
/* private data for volume */
static struct wl_resource *_volume_wl_touch = NULL;
static E_Client *_volume_ec = NULL;
/* event handler */
static Ecore_Event_Handler *_rot_handler = NULL;
static E_Client_Hook *_volume_del_hook = NULL;
+static E_Service_Volume_Listener *_volume_listener = NULL;
EINTERN E_Client *
e_service_volume_client_get(void)
}
static void
-_volume_client_evas_cb_show(void *data EINA_UNUSED, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_volume_client_view_cb_show(struct wl_listener *listener, void *data)
{
/* show region objects in current rotation */
REGION_OBJS_SHOW();
}
static void
-_volume_client_evas_cb_hide(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_volume_client_view_cb_hide(struct wl_listener *listener, void *data)
{
/* hide region objects in current rotation */
REGION_OBJS_HIDE();
}
static void
-_volume_client_evas_cb_move(void *data EINA_UNUSED, Evas *evas EINA_UNUSED, Evas_Object *volume_obj, void *event EINA_UNUSED)
+_volume_client_view_cb_move(struct wl_listener *listener, void *data)
{
Eina_List *l;
Eina_Rectangle *r;
if (EINA_UNLIKELY(r == NULL))
continue;
- evas_object_geometry_get(volume_obj, &x, &y, NULL, NULL);
+ e_view_client_geometry_get(e_client_view_get(_volume_ec), &x, &y, NULL, NULL);
evas_object_move(region_obj, x + r->x, y + r->y);
}
}
static void
-_volume_client_evas_cb_restack(void *data EINA_UNUSED, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_volume_client_view_cb_restack(struct wl_listener *listener, void *data)
{
Eina_List *l;
Evas_Object *region_obj;
{
_volume_ec_ev_init = EINA_FALSE;
- evas_object_event_callback_del(_volume_ec->frame, EVAS_CALLBACK_SHOW,
- _volume_client_evas_cb_show);
- evas_object_event_callback_del(_volume_ec->frame, EVAS_CALLBACK_HIDE,
- _volume_client_evas_cb_hide);
- evas_object_event_callback_del(_volume_ec->frame, EVAS_CALLBACK_MOVE,
- _volume_client_evas_cb_move);
- evas_object_event_callback_del(_volume_ec->frame, EVAS_CALLBACK_RESTACK,
- _volume_client_evas_cb_restack);
+ if (_volume_listener)
+ {
+ wl_list_remove(&_volume_listener->show_listener.link);
+ wl_list_remove(&_volume_listener->hide_listener.link);
+ wl_list_remove(&_volume_listener->move_listener.link);
+ wl_list_remove(&_volume_listener->restack_listener.link);
+ E_FREE(_volume_listener);
+ _volume_listener = NULL;
+ }
}
}
_volume_cur_angle_map = e_policy_angle_map(ec->e.state.rot.ang.curr);
/* repeat events for volume client. */
- evas_object_repeat_events_set(ec->frame, EINA_TRUE);
+ e_view_repeat_events_set(e_view_client_view_get(e_client_view_get(ec)), true);
_rot_handler =
ecore_event_handler_add(E_EVENT_CLIENT_ROTATION_CHANGE_END,
if (angle_map == _volume_cur_angle_map)
{
- if (evas_object_visible_get(_volume_ec->frame))
+ if (e_view_client_visible_get(e_client_view_get(_volume_ec)))
evas_object_show(obj);
}
}
e_service_volume_region_set(int type, int angle, Eina_Tiler *tiler)
{
E_Policy_Angle_Map angle_map;
+ E_View *view;
if (EINA_UNLIKELY(!_volume_ec))
{
if (!_volume_ec_ev_init)
{
+ _volume_listener = E_NEW(E_Service_Volume_Listener, 1);
+ if (!_volume_listener)
+ {
+ ERR("volume listener alloc fail");
+ return EINA_FALSE;
+ }
+
_volume_ec_ev_init = EINA_TRUE;
- evas_object_event_callback_add(_volume_ec->frame, EVAS_CALLBACK_SHOW,
- _volume_client_evas_cb_show, NULL);
- evas_object_event_callback_add(_volume_ec->frame, EVAS_CALLBACK_HIDE,
- _volume_client_evas_cb_hide, NULL);
- evas_object_event_callback_add(_volume_ec->frame, EVAS_CALLBACK_MOVE,
- _volume_client_evas_cb_move, NULL);
- evas_object_event_callback_add(_volume_ec->frame, EVAS_CALLBACK_RESTACK,
- _volume_client_evas_cb_restack, NULL);
+ view = e_view_client_view_get(e_client_view_get(_volume_ec));
+ _volume_listener->show_listener.notify = _volume_client_view_cb_show;
+ e_view_event_listener_add(view, E_VIEW_SHOW, &_volume_listener->show_listener);
+ _volume_listener->hide_listener.notify = _volume_client_view_cb_hide;
+ e_view_event_listener_add(view, E_VIEW_HIDE, &_volume_listener->hide_listener);
+ _volume_listener->move_listener.notify = _volume_client_view_cb_move;
+ e_view_event_listener_add(view, E_VIEW_MOVE, &_volume_listener->move_listener);
+ _volume_listener->restack_listener.notify = _volume_client_view_cb_restack;
+ e_view_event_listener_add(view, E_VIEW_RESTACK, &_volume_listener->restack_listener);
}
return EINA_TRUE;
#include <e_pixmap.h>
#include <e_bindings.h>
#include <e_config.h>
+#include <e_view.h>
+#include <e_view_client.h>
#include <uuid.h>
#include <Ecore.h>
Eina_Bool force_obscured : 1;
int last_sent_type;
Eina_Bool ignore_geometry : 1;
+
+ //view listener
+ struct wl_listener show_listener;
+ struct wl_listener hide_listener;
+ struct wl_listener move_listener;
+ struct wl_listener resize_listener;
+ struct wl_listener restack_listener;
} visibility;
struct
E_API Eina_Bool e_client_base_output_resolution_update(E_Client *ec);
E_API Eina_Bool e_client_base_output_resolution_useful_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h);
E_API Eina_Bool e_client_base_output_resolution_desk_useful_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h, Eina_Bool consider_obstacle_area);
+E_API E_View_Client *e_client_view_get(E_Client *ec);
typedef Eina_Bool (*E_Client_Surface_Tree_Foreach)(void *data, E_Client *ec);
#include <e_zone.h>
#include <e_desk.h>
#include <e_desk_area.h>
+#include "e_canvas.h"
+#include "e_view.h"
#ifdef __cplusplus
#include <atomic>
Ecore_Window ee_win;
Evas *evas;
- Evas_Object *bg_blank_object;
+ E_Canvas *canvas;
+ E_View *bg_blank_view;
Eina_List *zones;
E_Pointer *pointer;
Eina_List *clients;
Eina_List *post_updates;
Ecore_Animator *render_animator;
Ecore_Job *update_job;
- Evas_Object *fps_bg;
- Evas_Object *fps_fg;
+ E_View *fps_bg;
+ E_View *fps_fg;
int animating;
double frametimes[122];
double fps;
#define E_COMP_CANVAS_H
#include <e_types.h>
+#include <e_canvas.h>
E_API E_Zone *e_comp_zone_xy_get(Evas_Coord x, Evas_Coord y);
+E_API E_Canvas *e_comp_canvas_get(void);
E_API unsigned int e_comp_canvas_layer_map(E_Layer layer);
E_API unsigned int e_comp_canvas_client_layer_map(E_Layer layer);
E_API E_Layer e_comp_canvas_layer_map_to(unsigned int layer);
#include <e_presentation_time.h>
#include <e_zone.h>
#include <e_egl_sync.h>
+#include <e_view_rect.h>
#include <tbm_surface.h>
#include <wayland-server.h>
E_Zone *zone;
E_Object_Delfn *zone_delfn;
- Evas_Object *below_transparent_obj;
+ E_View_Rect *below_transparent_view;
Eina_Bool comp_override;
Eina_Bool never_hwc;
Eina_Bool hwc_visible;
Eina_Bool changed;
+
+ // view listener
+ struct wl_listener show_listener;
+ struct wl_listener hide_listener;
+ struct wl_listener move_listener;
+ struct wl_listener resize_listener;
+ struct wl_listener restack_listener;
+
+ struct wl_listener transparent_show_listener;
+ struct wl_listener transparent_hide_listener;
+ struct wl_listener transparent_move_listener;
+ struct wl_listener transparent_resize_listener;
+ struct wl_listener transparent_restack_listener;
};
struct _E_Hwc_Window_Target
E_API Eina_Bool e_map_util_zoom(E_Map *em, double zoomx, double zoomy, int cx, int cy);
E_API Eina_Bool e_map_util_rotate(E_Map *em, int angle, int cx, int cy);
+E_API Eina_Bool e_map_util_points_populate_from_view(E_Map *em, E_View *view);
+E_API Eina_Bool e_map_util_points_populate_from_view_full(E_Map *em, E_View *view, int z);
+
#ifdef __cplusplus
}
#endif
#include <Ecore.h>
#include <Ecore_Evas.h>
#include <Evas.h>
+#include <e_view_client.h>
typedef struct _E_Pointer E_Pointer;
typedef struct _E_Pointer_Hook E_Pointer_Hook;
Evas *evas;
Ecore_Evas *ee;
- Evas_Object *o_ptr;
+ E_View_Client *view_client;
+ struct wl_listener destroy_listener;
int x, y, w, h;
int rotation;
#include <e_zone.h>
#include <e_desk.h>
#include <e_module.h>
+#include <e_view_edje.h>
typedef struct _E_Policy_Softkey E_Policy_Softkey;
typedef struct _E_Policy_Softkey_Funcs E_Policy_Softkey_Funcs;
E_Zone *zone;
E_Policy_Softkey_Expand expand;
E_Policy_Softkey_Opacity opacity;
- Evas_Object *home;
- Evas_Object *back;
+ E_View_Edje *home;
+ E_View_Edje *back;
void *other;
};
Eina_Bool show_block;
Eina_List *events;
+
+ // view listener
+ struct wl_listener show_listener;
+ struct wl_listener hide_listener;
};
struct _E_Service_Softkey_Funcs
#include <e_actions.h>
#include <e_focus.h>
#include <e_desk.h>
+#include <e_view.h>
#define E_ZONE_TYPE (int)0xE0b0100d
Eina_List *handlers;
/* formerly E_Comp_Zone */
- Evas_Object *base;
- Evas_Object *over;
+ E_View *base;
+ E_View *over;
//double bl; // backlight level
//Eina_Bool bloff; // backlight is off
projects / platform / upstream / enlightenment.git / commitdiff