diff --git a/legacy/evas/ChangeLog b/legacy/evas/ChangeLog index b1f3eb4a4f..8ee08f965b 100644 --- a/legacy/evas/ChangeLog +++ b/legacy/evas/ChangeLog @@ -1080,4 +1080,9 @@ the GL calls are called within the Pixel Getter function for Direct Rendering option. +2012-10-09 Daniel Zaoui and Tom Hacohen + + * Evas: change Evas to use Eo. + This change adds Eo support to Evas while keeping the old API intact. + For more information, go to Eo. diff --git a/legacy/evas/configure.ac b/legacy/evas/configure.ac index 48374e15c5..85d5e142c3 100644 --- a/legacy/evas/configure.ac +++ b/legacy/evas/configure.ac @@ -266,6 +266,11 @@ PKG_CHECK_MODULES([FREETYPE], [freetype2 >= 9.3.0]) requirement_evas="freetype2 eina >= 1.6.0 ${requirement_evas}" +# Eo + +PKG_CHECK_MODULES([EO], [eo]) +requirement_evas="eo ${requirement_evas}" + ## optional dependencies # FontConfig @@ -1699,8 +1704,8 @@ AC_SUBST(EVAS_LIBS) # General CFLAGS -EVAS_GENERAL_CFLAGS="${EINA_CFLAGS}" -EVAS_GENERAL_LIBS="${EINA_LIBS}" +EVAS_GENERAL_CFLAGS="${EINA_CFLAGS} ${EO_CFLAGS}" +EVAS_GENERAL_LIBS="${EINA_LIBS} ${EO_LIBS}" AC_SUBST(EVAS_GENERAL_CFLAGS) AC_SUBST(EVAS_GENERAL_LIBS) diff --git a/legacy/evas/src/lib/Evas.h b/legacy/evas/src/lib/Evas.h index 8196ffca08..9adc728942 100644 --- a/legacy/evas/src/lib/Evas.h +++ b/legacy/evas/src/lib/Evas.h @@ -321,6 +321,9 @@ #include +/* This include has been added to support Eo in Evas */ +#include + #ifdef EAPI # undef EAPI #endif @@ -450,6 +453,74 @@ typedef enum _Evas_Callback_Type EVAS_CALLBACK_LAST /**< kept as last element/sentinel -- not really an event */ } Evas_Callback_Type; /**< The types of events triggering a callback */ +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_IN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_OUT; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_DOWN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_UP; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_MOVE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOUSE_WHEEL; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MULTI_DOWN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MULTI_UP; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MULTI_MOVE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_FREE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_KEY_DOWN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_KEY_UP; +EAPI extern const Eo_Event_Description _EVAS_EVENT_FOCUS_IN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_FOCUS_OUT; +EAPI extern const Eo_Event_Description _EVAS_EVENT_SHOW; +EAPI extern const Eo_Event_Description _EVAS_EVENT_HIDE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_MOVE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_RESIZE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_RESTACK; +EAPI extern const Eo_Event_Description _EVAS_EVENT_DEL; +EAPI extern const Eo_Event_Description _EVAS_EVENT_HOLD; +EAPI extern const Eo_Event_Description _EVAS_EVENT_CHANGED_SIZE_HINTS; +EAPI extern const Eo_Event_Description _EVAS_EVENT_IMAGE_PRELOADED; +EAPI extern const Eo_Event_Description _EVAS_EVENT_IMAGE_RESIZE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_IN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_OUT; +EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_PRE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_POST; +EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN; +EAPI extern const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT; +EAPI extern const Eo_Event_Description _EVAS_EVENT_IMAGE_UNLOADED; +EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_PRE; +EAPI extern const Eo_Event_Description _EVAS_EVENT_RENDER_POST; + +#define EVAS_EVENT_MOUSE_IN (&(_EVAS_EVENT_MOUSE_IN)) +#define EVAS_EVENT_MOUSE_OUT (&(_EVAS_EVENT_MOUSE_OUT)) +#define EVAS_EVENT_MOUSE_DOWN (&(_EVAS_EVENT_MOUSE_DOWN)) +#define EVAS_EVENT_MOUSE_UP (&(_EVAS_EVENT_MOUSE_UP)) +#define EVAS_EVENT_MOUSE_MOVE (&(_EVAS_EVENT_MOUSE_MOVE)) +#define EVAS_EVENT_MOUSE_WHEEL (&(_EVAS_EVENT_MOUSE_WHEEL)) +#define EVAS_EVENT_MULTI_DOWN (&(_EVAS_EVENT_MULTI_DOWN)) +#define EVAS_EVENT_MULTI_UP (&(_EVAS_EVENT_MULTI_UP)) +#define EVAS_EVENT_MULTI_MOVE (&(_EVAS_EVENT_MULTI_MOVE)) +#define EVAS_EVENT_FREE (&(_EVAS_EVENT_FREE)) +#define EVAS_EVENT_KEY_DOWN (&(_EVAS_EVENT_KEY_DOWN)) +#define EVAS_EVENT_KEY_UP (&(_EVAS_EVENT_KEY_UP)) +#define EVAS_EVENT_FOCUS_IN (&(_EVAS_EVENT_FOCUS_IN)) +#define EVAS_EVENT_FOCUS_OUT (&(_EVAS_EVENT_FOCUS_OUT)) +#define EVAS_EVENT_SHOW (&(_EVAS_EVENT_SHOW)) +#define EVAS_EVENT_HIDE (&(_EVAS_EVENT_HIDE)) +#define EVAS_EVENT_MOVE (&(_EVAS_EVENT_MOVE)) +#define EVAS_EVENT_RESIZE (&(_EVAS_EVENT_RESIZE)) +#define EVAS_EVENT_RESTACK (&(_EVAS_EVENT_RESTACK)) +#define EVAS_EVENT_DEL (&(_EVAS_EVENT_DEL)) +#define EVAS_EVENT_HOLD (&(_EVAS_EVENT_HOLD)) +#define EVAS_EVENT_CHANGED_SIZE_HINTS (&(_EVAS_EVENT_CHANGED_SIZE_HINTS)) +#define EVAS_EVENT_IMAGE_PRELOADED (&(_EVAS_EVENT_IMAGE_PRELOADED)) +#define EVAS_EVENT_IMAGE_RESIZE (&(_EVAS_EVENT_IMAGE_RESIZE)) +#define EVAS_EVENT_CANVAS_FOCUS_IN (&(_EVAS_EVENT_CANVAS_FOCUS_IN)) +#define EVAS_EVENT_CANVAS_FOCUS_OUT (&(_EVAS_EVENT_CANVAS_FOCUS_OUT)) +#define EVAS_EVENT_RENDER_FLUSH_PRE (&(_EVAS_EVENT_RENDER_FLUSH_PRE)) +#define EVAS_EVENT_RENDER_FLUSH_POST (&(_EVAS_EVENT_RENDER_FLUSH_POST)) +#define EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN (&(_EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN)) +#define EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT (&(_EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT)) +#define EVAS_EVENT_IMAGE_UNLOADED (&(_EVAS_EVENT_IMAGE_UNLOADED)) +#define EVAS_EVENT_RENDER_PRE (&(_EVAS_EVENT_RENDER_PRE)) +#define EVAS_EVENT_RENDER_POST (&(_EVAS_EVENT_RENDER_POST)) + /** * @def EVAS_CALLBACK_PRIORITY_BEFORE * Slightly more prioritized than default. @@ -481,7 +552,85 @@ typedef enum _Evas_Callback_Type * * @since 1.1 */ -typedef short Evas_Callback_Priority; +typedef Eo_Callback_Priority Evas_Callback_Priority; + +EAPI extern const Eo_Event_Description _CLICKED_EVENT; +EAPI extern const Eo_Event_Description _CLICKED_DOUBLE_EVENT; +EAPI extern const Eo_Event_Description _CLICKED_TRIPLE_EVENT; +EAPI extern const Eo_Event_Description _PRESSED_EVENT; +EAPI extern const Eo_Event_Description _UNPRESSED_EVENT; +EAPI extern const Eo_Event_Description _LONGPRESSED_EVENT; +EAPI extern const Eo_Event_Description _REPEATED_EVENT; +EAPI extern const Eo_Event_Description _SCROLL_EVENT; +EAPI extern const Eo_Event_Description _SCROLL_ANIM_START_EVENT; +EAPI extern const Eo_Event_Description _SCROLL_ANIM_STOP_EVENT; +EAPI extern const Eo_Event_Description _SCROLL_DRAG_START_EVENT; +EAPI extern const Eo_Event_Description _SCROLL_DRAG_STOP_EVENT; +EAPI extern const Eo_Event_Description _ZOOM_START_EVENT; +EAPI extern const Eo_Event_Description _ZOOM_STOP_EVENT; +EAPI extern const Eo_Event_Description _ZOOM_CHANGE_EVENT; +EAPI extern const Eo_Event_Description _SELECTED_EVENT; +EAPI extern const Eo_Event_Description _UNSELECTED_EVENT; +EAPI extern const Eo_Event_Description _SELECTION_PASTE_EVENT; +EAPI extern const Eo_Event_Description _SELECTION_COPY_EVENT; +EAPI extern const Eo_Event_Description _SELECTION_CUT_EVENT; +EAPI extern const Eo_Event_Description _SELECTION_START_EVENT; +EAPI extern const Eo_Event_Description _SELECTION_CHANGED_EVENT; +EAPI extern const Eo_Event_Description _SELECTION_CLEARED_EVENT; +EAPI extern const Eo_Event_Description _DRAG_EVENT; +EAPI extern const Eo_Event_Description _DRAG_START_EVENT; +EAPI extern const Eo_Event_Description _DRAG_STOP_EVENT; +EAPI extern const Eo_Event_Description _DRAG_END_EVENT; +EAPI extern const Eo_Event_Description _DRAG_START_UP_EVENT; +EAPI extern const Eo_Event_Description _DRAG_START_DOWN_EVENT; +EAPI extern const Eo_Event_Description _DRAG_START_RIGHT_EVENT; +EAPI extern const Eo_Event_Description _DRAG_START_LEFT_EVENT; + +#define EVAS_SMART_CLICKED_EVENT (&(_CLICKED_EVENT)) +#define EVAS_SMART_CLICKED_DOUBLE_EVENT (&(_CLICKED_DOUBLE_EVENT)) +#define EVAS_SMART_CLICKED_TRIPLE_EVENT (&(_CLICKED_TRIPLE_EVENT)) +#define EVAS_SMART_PRESSED_EVENT (&(_PRESSED_EVENT)) +#define EVAS_SMART_UNPRESSED_EVENT (&(_UNPRESSED_EVENT)) +#define EVAS_SMART_LONGPRESSED_EVENT (&(_LONGPRESSED_EVENT)) +#define EVAS_SMART_REPEATED_EVENT (&(_REPEATED_EVENT)) +#define EVAS_SMART_SCROLL_EVENT (&(_SCROLL_EVENT)) +#define EVAS_SMART_SCROLL_ANIM_START_EVENT (&(_SCROLL_ANIM_START_EVENT)) +#define EVAS_SMART_SCROLL_ANIM_STOP_EVENT (&(_SCROLL_ANIM_STOP_EVENT)) +#define EVAS_SMART_SCROLL_DRAG_START_EVENT (&(_SCROLL_DRAG_START_EVENT)) +#define EVAS_SMART_SCROLL_DRAG_STOP_EVENT (&(_SCROLL_DRAG_STOP_EVENT)) +#define EVAS_SMART_ZOOM_START_EVENT (&(_ZOOM_START_EVENT)) +#define EVAS_SMART_ZOOM_STOP_EVENT (&(_ZOOM_STOP_EVENT)) +#define EVAS_SMART_ZOOM_CHANGE_EVENT (&(_ZOOM_CHANGE_EVENT)) +#define EVAS_SMART_SELECTED_EVENT (&(_SELECTED_EVENT)) +#define EVAS_SMART_UNSELECTED_EVENT (&(_UNSELECTED_EVENT)) +#define EVAS_SMART_SELECTION_PASTE_EVENT (&(_SELECTION_PASTE_EVENT)) +#define EVAS_SMART_SELECTION_COPY_EVENT (&(_SELECTION_COPY_EVENT)) +#define EVAS_SMART_SELECTION_CUT_EVENT (&(_SELECTION_CUT_EVENT)) +#define EVAS_SMART_SELECTION_START_EVENT (&(_SELECTION_START_EVENT)) +#define EVAS_SMART_SELECTION_CHANGED_EVENT (&(_SELECTION_CHANGED_EVENT)) +#define EVAS_SMART_SELECTION_CLEARED_EVENT (&(_SELECTION_CLEARED_EVENT)) +#define EVAS_SMART_DRAG_EVENT (&(_DRAG_EVENT)) +#define EVAS_SMART_DRAG_START_EVENT (&(_DRAG_START_EVENT)) +#define EVAS_SMART_DRAG_STOP_EVENT (&(_DRAG_STOP_EVENT)) +#define EVAS_SMART_DRAG_END_EVENT (&(_DRAG_END_EVENT)) +#define EVAS_SMART_DRAG_START_UP_EVENT (&(_DRAG_START_UP_EVENT)) +#define EVAS_SMART_DRAG_START_DOWN_EVENT (&(_DRAG_START_DOWN_EVENT)) +#define EVAS_SMART_DRAG_START_RIGHT_EVENT (&(_DRAG_START_RIGHT_EVENT)) +#define EVAS_SMART_DRAG_START_LEFT_EVENT (&(_DRAG_START_LEFT_EVENT)) + +const Eo_Class *evas_smart_signal_interface_get(void) EINA_CONST; +const Eo_Class *evas_smart_clickable_interface_get(void) EINA_CONST; +const Eo_Class *evas_smart_scrollable_interface_get(void) EINA_CONST; +const Eo_Class *evas_smart_zoomable_interface_get(void) EINA_CONST; +const Eo_Class *evas_smart_selectable_interface_get(void) EINA_CONST; +const Eo_Class *evas_smart_draggable_interface_get(void) EINA_CONST; + +#define EVAS_SMART_SIGNAL_INTERFACE evas_smart_signal_interface_get() +#define EVAS_SMART_CLICKABLE_INTERFACE evas_smart_clickable_interface_get() +#define EVAS_SMART_SCROLLABLE_INTERFACE evas_smart_scrollable_interface_get() +#define EVAS_SMART_ZOOMABLE_INTERFACE evas_smart_zoomable_interface_get() +#define EVAS_SMART_SELECTABLE_INTERFACE evas_smart_selectable_interface_get() +#define EVAS_SMART_DRAGGABLE_INTERFACE evas_smart_draggable_interface_get() /** * Flags for Mouse Button events @@ -623,14 +772,28 @@ typedef struct _Evas_Map Evas_Map; * * @ingroup Evas_Canvas */ -typedef struct _Evas Evas; +typedef Eo Evas; + +/** + * @typedef Evas_Public_Data + * Public data for an Evas. + * @ingroup Evas_Canvas + */ +typedef struct _Evas_Public_Data Evas_Public_Data; /** * @typedef Evas_Object * An Evas Object handle. * @ingroup Evas_Object_Group */ -typedef struct _Evas_Object Evas_Object; +typedef Eo Evas_Object; + +/** + * @typedef Evas_Object_Protected_Data + * Protected data for an Evas Object. + * @ingroup Evas_Object_Group + */ +typedef struct _Evas_Object_Protected_Data Evas_Object_Protected_Data; typedef void Evas_Performance; /**< An Evas Performance handle */ typedef struct _Evas_Modifier Evas_Modifier; /**< An opaque type containing information on which modifier keys are registered in an Evas canvas */ @@ -2188,6 +2351,223 @@ EAPI int evas_pointer_button_down_mask_get(const Evas *e) EINA_WAR EAPI Eina_Bool evas_pointer_inside_get(const Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1); EAPI void evas_sync(Evas *e) EINA_ARG_NONNULL(1); + +#define EVAS_CLASS evas_class_get() + +const Eo_Class *evas_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_CANVAS_BASE_ID; + +enum +{ + EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_SET, + EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_GET, + EVAS_CANVAS_SUB_ID_ENGINE_INFO_GET, + EVAS_CANVAS_SUB_ID_ENGINE_INFO_SET, + EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_SET, + EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_GET, + EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_SET, + EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_GET, + EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_SET, + EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_GET, + EVAS_CANVAS_SUB_ID_COORD_SCREEN_X_TO_WORLD, + EVAS_CANVAS_SUB_ID_COORD_SCREEN_Y_TO_WORLD, + EVAS_CANVAS_SUB_ID_COORD_WORLD_X_TO_SCREEN, + EVAS_CANVAS_SUB_ID_COORD_WORLD_Y_TO_SCREEN, + EVAS_CANVAS_SUB_ID_POINTER_OUTPUT_XY_GET, + EVAS_CANVAS_SUB_ID_POINTER_CANVAS_XY_GET, + EVAS_CANVAS_SUB_ID_POINTER_BUTTON_DOWN_MASK_GET, + EVAS_CANVAS_SUB_ID_POINTER_INSIDE_GET, + EVAS_CANVAS_SUB_ID_DATA_ATTACH_SET, + EVAS_CANVAS_SUB_ID_DATA_ATTACH_GET, + EVAS_CANVAS_SUB_ID_FOCUS_IN, + EVAS_CANVAS_SUB_ID_FOCUS_OUT, + EVAS_CANVAS_SUB_ID_FOCUS_STATE_GET, + EVAS_CANVAS_SUB_ID_NOCHANGE_PUSH, + EVAS_CANVAS_SUB_ID_NOCHANGE_POP, + EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_SET, + EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_GET, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_DOWN, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_UP, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_CANCEL, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_WHEEL, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_MOVE, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_IN, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_OUT, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_DOWN, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_UP, + EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_MOVE, + EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_DOWN, + EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_UP, + EVAS_CANVAS_SUB_ID_EVENT_FEED_HOLD, + EVAS_CANVAS_SUB_ID_EVENT_REFEED_EVENT, + EVAS_CANVAS_SUB_ID_EVENT_DOWN_COUNT_GET, + EVAS_CANVAS_SUB_ID_FOCUS_GET, + EVAS_CANVAS_SUB_ID_FONT_PATH_CLEAR, + EVAS_CANVAS_SUB_ID_FONT_PATH_APPEND, + EVAS_CANVAS_SUB_ID_FONT_PATH_PREPEND, + EVAS_CANVAS_SUB_ID_FONT_PATH_LIST, + EVAS_CANVAS_SUB_ID_FONT_HINTING_SET, + EVAS_CANVAS_SUB_ID_FONT_HINTING_GET, + EVAS_CANVAS_SUB_ID_FONT_HINTING_CAN_HINT, + EVAS_CANVAS_SUB_ID_FONT_CACHE_FLUSH, + EVAS_CANVAS_SUB_ID_FONT_CACHE_SET, + EVAS_CANVAS_SUB_ID_FONT_CACHE_GET, + EVAS_CANVAS_SUB_ID_FONT_AVAILABLE_LIST, + EVAS_CANVAS_SUB_ID_KEY_MODIFIER_GET, + EVAS_CANVAS_SUB_ID_KEY_LOCK_GET, + EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ADD, + EVAS_CANVAS_SUB_ID_KEY_MODIFIER_DEL, + EVAS_CANVAS_SUB_ID_KEY_LOCK_ADD, + EVAS_CANVAS_SUB_ID_KEY_LOCK_DEL, + EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ON, + EVAS_CANVAS_SUB_ID_KEY_MODIFIER_OFF, + EVAS_CANVAS_SUB_ID_KEY_LOCK_ON, + EVAS_CANVAS_SUB_ID_KEY_LOCK_OFF, + EVAS_CANVAS_SUB_ID_KEY_MODIFIER_MASK_GET, + EVAS_CANVAS_SUB_ID_DAMAGE_RECTANGLE_ADD, + EVAS_CANVAS_SUB_ID_OBSCURED_RECTANGLE_ADD, + EVAS_CANVAS_SUB_ID_OBSCURED_CLEAR, + EVAS_CANVAS_SUB_ID_RENDER_UPDATES, + EVAS_CANVAS_SUB_ID_RENDER, + EVAS_CANVAS_SUB_ID_NORENDER, + EVAS_CANVAS_SUB_ID_RENDER_IDLE_FLUSH, + EVAS_CANVAS_SUB_ID_SYNC, + EVAS_CANVAS_SUB_ID_RENDER_DUMP, + EVAS_CANVAS_SUB_ID_OBJECT_BOTTOM_GET, + EVAS_CANVAS_SUB_ID_OBJECT_TOP_GET, + EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_COUNT, + EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_XY_GET, + EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_ID_GET, + EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_STATE_GET, + EVAS_CANVAS_SUB_ID_IMAGE_CACHE_FLUSH, + EVAS_CANVAS_SUB_ID_IMAGE_CACHE_RELOAD, + EVAS_CANVAS_SUB_ID_IMAGE_CACHE_SET, + EVAS_CANVAS_SUB_ID_IMAGE_CACHE_GET, + EVAS_CANVAS_SUB_ID_IMAGE_MAX_SIZE_GET, + EVAS_CANVAS_SUB_ID_OBJECT_NAME_FIND, + EVAS_CANVAS_SUB_ID_OBJECT_TOP_AT_XY_GET, + EVAS_CANVAS_SUB_ID_OBJECT_TOP_IN_RECTANGLE_GET, + EVAS_CANVAS_SUB_ID_OBJECTS_AT_XY_GET, + EVAS_CANVAS_SUB_ID_OBJECTS_IN_RECTANGLE_GET, + EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE, + EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE_COUNT_GET, + EVAS_CANVAS_SUB_ID_LAST +}; + +#define EVAS_CANVAS_ID(sub_id) (EVAS_CANVAS_BASE_ID + sub_id) + +#define evas_canvas_output_method_set(render_method) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_SET), EO_TYPECHECK(int, render_method) +#define evas_canvas_output_method_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_GET), EO_TYPECHECK(int *, ret) +#define evas_canvas_engine_info_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_ENGINE_INFO_GET), EO_TYPECHECK(Evas_Engine_Info **, ret) +#define evas_canvas_engine_info_set(info, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_ENGINE_INFO_SET), EO_TYPECHECK(Evas_Engine_Info *, info), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_canvas_output_size_set(w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_SET), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) +#define evas_canvas_output_size_get(w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_GET), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h) +#define evas_canvas_output_viewport_set(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_SET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) +#define evas_canvas_output_viewport_get(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) +#define evas_canvas_output_framespace_set(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_SET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) +#define evas_canvas_output_framespace_get(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) +#define evas_canvas_coord_screen_x_to_world(x, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_SCREEN_X_TO_WORLD), EO_TYPECHECK(int, x), EO_TYPECHECK(Evas_Coord *, ret) +#define evas_canvas_coord_screen_y_to_world(y, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_SCREEN_Y_TO_WORLD), EO_TYPECHECK(int, y), EO_TYPECHECK(Evas_Coord *, ret) +#define evas_canvas_coord_world_x_to_screen(x, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_WORLD_X_TO_SCREEN), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(int *, ret) +#define evas_canvas_coord_world_y_to_screen(y, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_WORLD_Y_TO_SCREEN), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(int *, ret) +#define evas_canvas_pointer_output_xy_get(x, y) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_OUTPUT_XY_GET), EO_TYPECHECK(int *, x), EO_TYPECHECK(int *, y) +#define evas_canvas_pointer_canvas_xy_get(x, y) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_CANVAS_XY_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y) +#define evas_canvas_pointer_button_down_mask_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_BUTTON_DOWN_MASK_GET), EO_TYPECHECK(int *, ret) +#define evas_canvas_pointer_inside_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_INSIDE_GET), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_canvas_data_attach_set(data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DATA_ATTACH_SET), EO_TYPECHECK(void *, data) +#define evas_canvas_data_attach_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DATA_ATTACH_GET), EO_TYPECHECK(void **, ret) +#define evas_canvas_focus_in() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_IN) +#define evas_canvas_focus_out() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_OUT) +#define evas_canvas_focus_state_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_STATE_GET), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_canvas_nochange_push() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_NOCHANGE_PUSH) +#define evas_canvas_nochange_pop() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_NOCHANGE_POP) + +#define evas_canvas_event_default_flags_set(flags) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_SET), EO_TYPECHECK(Evas_Event_Flags, flags) +#define evas_canvas_event_default_flags_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_GET), EO_TYPECHECK(Evas_Event_Flags *, ret) +#define evas_canvas_event_freeze() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FREEZE) +#define evas_canvas_event_thaw() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_THAW) +#define evas_canvas_event_freeze_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FREEZE_GET), EO_TYPECHECK(int *, ret) +#define evas_canvas_event_thaw_eval() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_THAW_EVAL) +#define evas_canvas_event_feed_mouse_down(b, flags, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_DOWN), EO_TYPECHECK(int, b), EO_TYPECHECK(Evas_Button_Flags, flags), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_mouse_up(b, flags, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_UP), EO_TYPECHECK(int, b), EO_TYPECHECK(Evas_Button_Flags, flags), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_mouse_cancel(timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_CANCEL), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_mouse_wheel(direction, z, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_WHEEL), EO_TYPECHECK(int, direction), EO_TYPECHECK(int, z), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_mouse_move(x, y, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_MOVE), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_mouse_in(timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_IN), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_mouse_out(timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_OUT), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_multi_down(d, x, y, rad, radx, rady, pres, ang, fx, fy, flags, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_DOWN), EO_TYPECHECK(int, d), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(double, rad), EO_TYPECHECK(double, radx), EO_TYPECHECK(double, rady), EO_TYPECHECK(double, pres), EO_TYPECHECK(double, ang), EO_TYPECHECK(double, fx), EO_TYPECHECK(double, fy), EO_TYPECHECK(Evas_Button_Flags, flags), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_multi_up(d, x, y, rad, radx, rady, pres, ang, fx, fy, flags, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_UP), EO_TYPECHECK(int, d), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(double, rad), EO_TYPECHECK(double, radx), EO_TYPECHECK(double, rady), EO_TYPECHECK(double, pres), EO_TYPECHECK(double, ang), EO_TYPECHECK(double, fx), EO_TYPECHECK(double, fy), EO_TYPECHECK(Evas_Button_Flags, flags), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_multi_move(d, x, y, rad, radx, rady, pres, ang, fx, fy, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_MOVE), EO_TYPECHECK(int, d), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(double, rad), EO_TYPECHECK(double, radx), EO_TYPECHECK(double, rady), EO_TYPECHECK(double, pres), EO_TYPECHECK(double, ang), EO_TYPECHECK(double, fx), EO_TYPECHECK(double, fy), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_key_down(keyname, key, string, compose, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_DOWN), EO_TYPECHECK(const char *, keyname), EO_TYPECHECK(const char *, key), EO_TYPECHECK(const char *, string), EO_TYPECHECK(const char *, compose), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_key_up(keyname, key, string, compose, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_UP), EO_TYPECHECK(const char *, keyname), EO_TYPECHECK(const char *, key), EO_TYPECHECK(const char *, string), EO_TYPECHECK(const char *, compose), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_feed_hold(hold, timestamp, data) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_HOLD), EO_TYPECHECK(int, hold), EO_TYPECHECK(unsigned int, timestamp), EO_TYPECHECK(const void *, data) +#define evas_canvas_event_refeed_event(event_copy, event_type) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_REFEED_EVENT), EO_TYPECHECK(void *, event_copy), EO_TYPECHECK(Evas_Callback_Type, event_type) +#define evas_canvas_event_down_count_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_DOWN_COUNT_GET), EO_TYPECHECK(int *, ret) + +#define evas_canvas_focus_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_GET), EO_TYPECHECK(Evas_Object **, ret) + +#define evas_canvas_font_path_clear() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_CLEAR) +#define evas_canvas_font_path_append(path) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_APPEND), EO_TYPECHECK(const char *, path) +#define evas_canvas_font_path_prepend(path) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_PREPEND), EO_TYPECHECK(const char *, path) +#define evas_canvas_font_path_list(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_LIST), EO_TYPECHECK(const Eina_List **, ret) +#define evas_canvas_font_hinting_set(hinting) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_HINTING_SET), EO_TYPECHECK(Evas_Font_Hinting_Flags, hinting) +#define evas_canvas_font_hinting_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_HINTING_GET), EO_TYPECHECK(Evas_Font_Hinting_Flags *, ret) +#define evas_canvas_font_hinting_can_hint(hinting, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_HINTING_CAN_HINT), EO_TYPECHECK(Evas_Font_Hinting_Flags, hinting), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_canvas_font_cache_flush() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_CACHE_FLUSH) +#define evas_canvas_font_cache_set(size) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_CACHE_SET), EO_TYPECHECK(int, size) +#define evas_canvas_font_cache_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_CACHE_GET), EO_TYPECHECK(int *, ret) +#define evas_canvas_font_available_list(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_AVAILABLE_LIST), EO_TYPECHECK(Eina_List **, ret) + +#define evas_canvas_key_modifier_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_GET), EO_TYPECHECK(const Evas_Modifier **, ret) +#define evas_canvas_key_lock_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_GET), EO_TYPECHECK(const Evas_Lock **, ret) +#define evas_canvas_key_modifier_add(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ADD), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_modifier_del(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_DEL), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_lock_add(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_ADD), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_lock_del(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_DEL), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_modifier_on(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ON), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_modifier_off(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_OFF), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_lock_on(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_ON), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_lock_off(keyname) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_OFF), EO_TYPECHECK(const char *, keyname) +#define evas_canvas_key_modifier_mask_get(keyname, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_MASK_GET), EO_TYPECHECK(const char *, keyname), EO_TYPECHECK(Evas_Modifier_Mask *, ret) + +#define evas_canvas_damage_rectangle_add(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DAMAGE_RECTANGLE_ADD), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) +#define evas_canvas_obscured_rectangle_add(x, y, w, h) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBSCURED_RECTANGLE_ADD), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) +#define evas_canvas_obscured_clear() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBSCURED_CLEAR) +#define evas_canvas_render_updates(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER_UPDATES), EO_TYPECHECK(Eina_List **, ret) +#define evas_canvas_render() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER) +#define evas_canvas_norender() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_NORENDER) +#define evas_canvas_render_idle_flush() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER_IDLE_FLUSH) +#define evas_canvas_sync() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_SYNC) +#define evas_canvas_render_dump() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER_DUMP) + +#define evas_canvas_object_bottom_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_BOTTOM_GET), EO_TYPECHECK(Evas_Object **, ret) +#define evas_canvas_object_top_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_TOP_GET), EO_TYPECHECK(Evas_Object **, ret) + +#define evas_canvas_touch_point_list_count(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_COUNT), EO_TYPECHECK(unsigned int *, ret) +#define evas_canvas_touch_point_list_nth_xy_get(n, x, y) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_XY_GET), EO_TYPECHECK(unsigned int, n), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y) +#define evas_canvas_touch_point_list_nth_id_get(n, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_ID_GET), EO_TYPECHECK(unsigned int, n), EO_TYPECHECK(int *, ret) +#define evas_canvas_touch_point_list_nth_state_get(n, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_STATE_GET), EO_TYPECHECK(unsigned int, n), EO_TYPECHECK(Evas_Touch_Point_State *, ret) + +#define evas_canvas_image_cache_flush() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_FLUSH) +#define evas_canvas_image_cache_reload() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_RELOAD) +#define evas_canvas_image_cache_set(size) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_SET), EO_TYPECHECK(int, size) +#define evas_canvas_image_cache_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_GET), EO_TYPECHECK(int *, ret) +#define evas_canvas_image_max_size_get(maxw, maxh, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_MAX_SIZE_GET), EO_TYPECHECK(int *, maxw), EO_TYPECHECK(int *, maxh), EO_TYPECHECK(Eina_Bool *, ret) + +#define evas_canvas_object_name_find(name, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_NAME_FIND),EO_TYPECHECK(const char *, name), EO_TYPECHECK(Evas_Object **, ret) + +#define evas_canvas_object_top_at_xy_get(x, y, include_pass_events_objects, include_hidden_objects, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_TOP_AT_XY_GET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Eina_Bool, include_pass_events_objects), EO_TYPECHECK(Eina_Bool, include_hidden_objects), EO_TYPECHECK(Evas_Object **, ret) +#define evas_canvas_object_top_in_rectangle_get(x, y, w, h, include_pass_events_objects, include_hidden_objects, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_TOP_IN_RECTANGLE_GET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h), EO_TYPECHECK(Eina_Bool, include_pass_events_objects), EO_TYPECHECK(Eina_Bool, include_hidden_objects), EO_TYPECHECK(Evas_Object **, ret) +#define evas_canvas_objects_at_xy_get(x, y, include_pass_events_objects, include_hidden_objects, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECTS_AT_XY_GET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Eina_Bool, include_pass_events_objects), EO_TYPECHECK(Eina_Bool, include_hidden_objects), EO_TYPECHECK(Eina_List **, ret) +#define evas_canvas_objects_in_rectangle_get(x, y, w, h, include_pass_events_objects, include_hidden_objects, ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECTS_IN_RECTANGLE_GET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h), EO_TYPECHECK(Eina_Bool, include_pass_events_objects), EO_TYPECHECK(Eina_Bool, include_hidden_objects), EO_TYPECHECK(Eina_List **, ret) + +#define evas_canvas_smart_objects_calculate() EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE) +#define evas_canvas_smart_objects_calculate_count_get(ret) EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE_COUNT_GET), EO_TYPECHECK(int *, ret) + + + + /** * @defgroup Evas_Canvas_Events Canvas Events @@ -6397,6 +6777,19 @@ EAPI void *evas_object_intercept_clip_unset_callback_del(Evas_Object *obj, Evas_ * @ingroup Evas_Object_Specific */ +#define EVAS_OBJ_RECTANGLE_CLASS evas_object_rectangle_class_get() + +const Eo_Class *evas_object_rectangle_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_RECTANGLE_BASE_ID; + +enum +{ + EVAS_OBJ_RECTANGLE_SUB_ID_LAST +}; + +#define EVAS_OBJ_RECTANGLE_ID(sub_id) (EVAS_OBJ_RECTANGLE_BASE_ID + sub_id) + /** * Adds a rectangle to the given evas. * @param e The given evas. @@ -7904,6 +8297,408 @@ typedef enum _Evas_Text_Style_Type EVAS_TEXT_STYLE_SHADOW_DIRECTION_RIGHT = (0x7 << 4) /**< shadow growing to the right */ } Evas_Text_Style_Type; /**< Types of styles to be applied on text objects. The @c EVAS_TEXT_STYLE_SHADOW_DIRECTION_* ones are to be ORed together with others imposing shadow, to change shadow's direction */ +#define EVAS_OBJ_TEXT_CLASS evas_object_text_class_get() + +const Eo_Class *evas_object_text_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_TEXT_BASE_ID; + +enum +{ + EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_SET, + EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_GET, + EVAS_OBJ_TEXT_SUB_ID_FONT_SET, + EVAS_OBJ_TEXT_SUB_ID_FONT_GET, + EVAS_OBJ_TEXT_SUB_ID_TEXT_SET, + EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_SET, + EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_GET, + EVAS_OBJ_TEXT_SUB_ID_TEXT_GET, + EVAS_OBJ_TEXT_SUB_ID_DIRECTION_GET, + EVAS_OBJ_TEXT_SUB_ID_ASCENT_GET, + EVAS_OBJ_TEXT_SUB_ID_DESCENT_GET, + EVAS_OBJ_TEXT_SUB_ID_MAX_ASCENT_GET, + EVAS_OBJ_TEXT_SUB_ID_MAX_DESCENT_GET, + EVAS_OBJ_TEXT_SUB_ID_INSET_GET, + EVAS_OBJ_TEXT_SUB_ID_HORIZ_ADVANCE_GET, + EVAS_OBJ_TEXT_SUB_ID_VERT_ADVANCE_GET, + EVAS_OBJ_TEXT_SUB_ID_CHAR_POS_GET, + EVAS_OBJ_TEXT_SUB_ID_LAST_UP_TO_POS, + EVAS_OBJ_TEXT_SUB_ID_CHAR_COORDS_GET, + EVAS_OBJ_TEXT_SUB_ID_STYLE_SET, + EVAS_OBJ_TEXT_SUB_ID_STYLE_GET, + EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_SET, + EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_GET, + EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_SET, + EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_GET, + EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_SET, + EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_GET, + EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_SET, + EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_GET, + EVAS_OBJ_TEXT_SUB_ID_STYLE_PAD_GET, + EVAS_OBJ_TEXT_SUB_ID_LAST +}; + +#define EVAS_OBJ_TEXT_ID(sub_id) (EVAS_OBJ_TEXT_BASE_ID + sub_id) + +/** + * @def evas_obj_text_font_source_set + * + * Set the font (source) file to be used on a given text object. + * + * @param[in] font_source in + * + * @see evas_object_text_font_source_set + */ +#define evas_obj_text_font_source_set(font_source) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_SET), EO_TYPECHECK(const char *, font_source) + +/** + * @def evas_obj_text_font_source_get + * + * Get the font file's path which is being used on a given text + * object. + * + * @param[out] font_source out + * + * @see evas_object_text_font_source_get + */ +#define evas_obj_text_font_source_get(font_source) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_GET), EO_TYPECHECK(const char **, font_source) + +/** + * @def evas_obj_text_font_set + * + * Set the font family and size on a given text object. + * + * @param[in] font in + * @param[in] size in + * + * @see evas_object_text_font_set + */ +#define evas_obj_text_font_set(font, size) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_SET), EO_TYPECHECK(const char *, font), EO_TYPECHECK(Evas_Font_Size, size) + +/** + * @def evas_obj_text_font_get + * + * Retrieve the font family and size in use on a given text object. + * + * @param[out] font out + * @param[out] size out + * + * @see evas_object_text_font_get + */ +#define evas_obj_text_font_get(font, size) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_GET), EO_TYPECHECK(const char **, font), EO_TYPECHECK(Evas_Font_Size *, size) + +/** + * @def evas_obj_text_text_set + * + * Sets the text string to be displayed by the given text object. + * + * @param[in] text + * + * @see evas_object_text_text_set + */ +#define evas_obj_text_text_set(text) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_TEXT_SET), EO_TYPECHECK(const char *, text) + +/** + * @def evas_obj_text_bidi_delimiters_set + * + * Retrieves the text string currently being displayed by the given + * text object. + * + * @param[in] delim in + * + * @see evas_object_text_text_get + */ +#define evas_obj_text_text_get(text) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_TEXT_GET), EO_TYPECHECK(const char **, text) + +/** + * @def evas_obj_text_bidi_delimiters_set + * + * Sets the BiDi delimiters used in the textblock. + * + * @param[in] delim in + * + * @see evas_object_text_bidi_delimiters_set + */ +#define evas_obj_text_bidi_delimiters_set(delim) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_SET), EO_TYPECHECK(const char *, delim) + +/** + * @def evas_obj_text_bidi_delimiters_get + * + * Gets the BiDi delimiters used in the textblock. + * + * @param[out] delim out + * + * @see evas_object_text_bidi_delimiters_get + */ +#define evas_obj_text_bidi_delimiters_get(delim) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_GET), EO_TYPECHECK(const char **, delim) + +/** + * @def evas_obj_text_direction_get + * + * Retrieves the direction of the text currently being displayed in the + * text object. + * + * @param[out] bidi_dir out + * + * @see evas_object_text_direction_get + */ +#define evas_obj_text_direction_get(bidi_dir) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_DIRECTION_GET), EO_TYPECHECK(Evas_BiDi_Direction *, bidi_dir) + +/** + * @def evas_obj_text_ascent_get + * + * @param[out] ascent out + * + * @see evas_object_text_ascent_get + */ +#define evas_obj_text_ascent_get(ascent) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_ASCENT_GET), EO_TYPECHECK(Evas_Coord *, ascent) + +/** + * @def evas_obj_text_descent_get + * + * @param[out] descent out + * + * @see evas_object_text_descent_get + */ +#define evas_obj_text_descent_get(descent) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_DESCENT_GET), EO_TYPECHECK(Evas_Coord *, descent) + +/** + * @def evas_obj_text_max_ascent_get + * + * @param[out] max_ascent out + * + * @see evas_object_text_max_ascent_get + */ +#define evas_obj_text_max_ascent_get(max_ascent) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_MAX_ASCENT_GET), EO_TYPECHECK(Evas_Coord *, max_ascent) + +/** + * @def evas_obj_text_max_descent_get + * + * @param[out] max_descent out + * + * @see evas_object_text_max_descent_get + */ +#define evas_obj_text_max_descent_get(max_descent) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_MAX_DESCENT_GET), EO_TYPECHECK(Evas_Coord *, max_descent) + +/** + * @def evas_obj_text_inset_get + * + * @param[out] inset out + * + * @see evas_object_text_inset_get + */ +#define evas_obj_text_inset_get(inset) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_INSET_GET), EO_TYPECHECK(Evas_Coord *, inset) + +/** + * @def evas_obj_text_horiz_advance_get + * + * @param[out] horiz out + * + * @see evas_object_text_horiz_advance_get + */ +#define evas_obj_text_horiz_advance_get(horiz) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_HORIZ_ADVANCE_GET), EO_TYPECHECK(Evas_Coord *, horiz) + +/** + * @def evas_obj_text_vert_advance_get_ + * + * @param[out] vert out + * + * @see evas_object_text_vert_advance_get + */ +#define evas_obj_text_vert_advance_get(vert) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_VERT_ADVANCE_GET), EO_TYPECHECK(Evas_Coord *, vert) +/** + * @def evas_obj_text_char_pos_get + * + * Retrieve position and dimension information of a character within a text @c Evas_Object. + * + * @param[in] pos in + * @param[out] cx out + * @param[out] cy out + * @param[out] cw out + * @param[out] ch out + * @param[out] ret out + * + * @see evas_object_text_char_pos_get + */ +#define evas_obj_text_char_pos_get(pos, cx, cy, cw, ch, ret) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_CHAR_POS_GET), EO_TYPECHECK(int, pos), EO_TYPECHECK(Evas_Coord *, cx), EO_TYPECHECK(Evas_Coord *, cy), EO_TYPECHECK(Evas_Coord *, cw), EO_TYPECHECK(Evas_Coord *, ch), EO_TYPECHECK(Eina_Bool *, ret) + +/** + * @def evas_obj_text_last_up_to_pos + * + * Returns the logical position of the last char in the text + * up to the pos given. this is NOT the position of the last char + * because of the possibility of RTL in the text. + * + * @param[in] x in + * @param[in] y in + * @param[out] res out + * + * @see evas_object_text_last_up_to_pos + */ +#define evas_obj_text_last_up_to_pos(x, y, res) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_LAST_UP_TO_POS), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(int *, res) +/** + * @def evas_obj_text_char_coords_get + * + * @param[in] x in + * @param[in] y in + * @param[out] cx out + * @param[out] cy out + * @param[out] cw out + * @param[out] ch out + * @param[out] res out + * + * @see evas_object_text_char_coords_get + */ +#define evas_obj_text_char_coords_get(x, y, cx, cy, cw, ch, res) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_CHAR_COORDS_GET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord *, cx), EO_TYPECHECK(Evas_Coord *, cy), EO_TYPECHECK(Evas_Coord *, cw), EO_TYPECHECK(Evas_Coord *, ch), EO_TYPECHECK(int *, res) + +/** + * @def evas_obj_text_style_set + * + * Sets the style to apply on the given text object. + * + * @param[in] style in + * + * @see evas_object_text_style_set + */ +#define evas_obj_text_style_set(style) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_STYLE_SET), EO_TYPECHECK(Evas_Text_Style_Type, style) + +/** + * @def evas_obj_text_style_get + * + * Retrieves the style on use on the given text object. + * + * @param[out] style out + * + * @see evas_object_text_style_get + */ +#define evas_obj_text_style_get(style) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_STYLE_GET), EO_TYPECHECK(Evas_Text_Style_Type *, style) + +/** + * @def evas_obj_text_shadow_color_set + * + * Sets the shadow color for the given text object. + * + * @param[in] r in + * @param[in] g in + * @param[in] b in + * @param[in] a in + * + * @see evas_object_text_shadow_color_set + */ +#define evas_obj_text_shadow_color_set(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_SET), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) + +/** + * @def evas_obj_text_shadow_color_get + * + * Retrieves the shadow color for the given text object. + * + * @param[out] r out + * @param[out] g out + * @param[out] b out + * @param[out] a out + * + * @see evas_object_text_shadow_color_get + */ +#define evas_obj_text_shadow_color_get(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_GET), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, g), EO_TYPECHECK(int *, b), EO_TYPECHECK(int *, a) + +/** + * @def evas_obj_text_glow_color_set + * + * Sets the glow color for the given text object. + * + * @param[in] r in + * @param[in] g in + * @param[in] b in + * @param[in] a in + * + * @see evas_object_text_glow_color_set + */ +#define evas_obj_text_glow_color_set(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_SET), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) + +/** + * @def evas_obj_text_glow_color_get + * + * Retrieves the glow color for the given text object. + * + * @param[out] r out + * @param[out] g out + * @param[out] b out + * @param[out] a out + * + * @see evas_object_text_glow_color_get + */ +#define evas_obj_text_glow_color_get(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_GET), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, g), EO_TYPECHECK(int *, b), EO_TYPECHECK(int *, a) + +/** + * @def evas_obj_text_glow2_color_set + * + * Sets the 'glow 2' color for the given text object. + * + * @param[in] r in + * @param[in] g in + * @param[in] b in + * @param[in] a in + * + * @see evas_object_text_glow2_color_set + */ +#define evas_obj_text_glow2_color_set(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_SET), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) + +/** + * @def evas_obj_text_glow2_color_get + * + * Retrieves the 'glow 2' color for the given text object. + * + * @param[out] r out + * @param[out] g out + * @param[out] b out + * @param[out] a out + * + * @see evas_object_text_glow2_color_get + */ +#define evas_obj_text_glow2_color_get(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_GET), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, g), EO_TYPECHECK(int *, b), EO_TYPECHECK(int *, a) + +/** + * @def evas_obj_text_outline_color_set + * + * Sets the outline color for the given text object. + * + * @param[in] r in + * @param[in] g in + * @param[in] b in + * @param[in] a in + * + * @see evas_object_text_outline_color_set + */ +#define evas_obj_text_outline_color_set(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_SET), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) + +/** + * @def evas_obj_text_outline_color_get + * + * Retrieves the outline color for the given text object. + * + * @param[out] r out + * @param[out] g out + * @param[out] b out + * @param[out] a out + * + * @see evas_object_text_outline_color_get + */ +#define evas_obj_text_outline_color_get(r, g, b, a) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_GET), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, g), EO_TYPECHECK(int *, b), EO_TYPECHECK(int *, a) + +/** + * @def evas_obj_text_style_pad_get + * + * Gets the text style pad of a text object. + * + * @param[out] l out + * @param[out] r out + * @param[out] t out + * @param[out] b out + * + * @see evas_object_text_style_pad_get + */ +#define evas_obj_text_style_pad_get(l, r, t, b) EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_STYLE_PAD_GET), EO_TYPECHECK(int *, l), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, t), EO_TYPECHECK(int *, b) + /** * Creates a new text object on the provided canvas. * @@ -8448,6 +9243,72 @@ typedef enum _Evas_Textblock_Cursor_Type EVAS_TEXTBLOCK_CURSOR_BEFORE } Evas_Textblock_Cursor_Type; +#define EVAS_OBJ_TEXTBLOCK_CLASS evas_object_textblock_class_get() + +const Eo_Class *evas_object_textblock_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_TEXTBLOCK_BASE_ID; + +enum +{ + EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_SET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PUSH, + EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PEEK, + EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_POP, + EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_SET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_SET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_SET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_SET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_SET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_NEW, + EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LIST_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_FIRST_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LAST_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_REMOVE_PAIR, + EVAS_OBJ_TEXTBLOCK_SUB_ID_LINE_NUMBER_GEOMETRY_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_CLEAR, + EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_FORMATTED_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_NATIVE_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_INSETS_GET, + EVAS_OBJ_TEXTBLOCK_SUB_ID_LAST +}; + +#define EVAS_OBJ_TEXTBLOCK_ID(sub_id) (EVAS_OBJ_TEXTBLOCK_BASE_ID + sub_id) + +#define evas_obj_textblock_style_set(ts) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_SET), EO_TYPECHECK(Evas_Textblock_Style *, ts) +#define evas_obj_textblock_style_get(ts) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_GET), EO_TYPECHECK(const Evas_Textblock_Style **, ts) +#define evas_obj_textblock_style_user_push(ts) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PUSH), EO_TYPECHECK(Evas_Textblock_Style *, ts) +#define evas_obj_textblock_style_user_peek(ts) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PEEK), EO_TYPECHECK(const Evas_Textblock_Style **, ts) +#define evas_obj_textblock_style_user_pop() EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_POP) +#define evas_obj_textblock_replace_char_set(ch) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_SET), EO_TYPECHECK(const char *, ch) +#define evas_obj_textblock_legacy_newline_set(mode) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_SET), EO_TYPECHECK(Eina_Bool, mode) +#define evas_obj_textblock_legacy_newline_get(newline) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_GET), EO_TYPECHECK(Eina_Bool *, newline) +#define evas_obj_textblock_valign_set(align) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_SET), EO_TYPECHECK(double, align) +#define evas_obj_textblock_valign_get(valign) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_GET), EO_TYPECHECK(double *, valign) +#define evas_obj_textblock_bidi_delimiters_set(delim) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_SET), EO_TYPECHECK(const char *, delim) +#define evas_obj_textblock_bidi_delimiters_get(delim) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_GET), EO_TYPECHECK(const char **, delim) +#define evas_obj_textblock_replace_char_get(repch) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_GET), EO_TYPECHECK(const char **, repch) +#define evas_obj_textblock_text_markup_set(text) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_SET), EO_TYPECHECK(const char *, text) +#define evas_obj_textblock_text_markup_get(markup) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_GET), EO_TYPECHECK(const char **, markup) +#define evas_obj_textblock_cursor_get(cursor) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_GET), EO_TYPECHECK(Evas_Textblock_Cursor **, cursor) +#define evas_obj_textblock_cursor_new(cur) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_NEW), EO_TYPECHECK(Evas_Textblock_Cursor **, cur) +#define evas_obj_textblock_node_format_list_get(obj, anchor, list) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LIST_GET), EO_TYPECHECK(const char *, anchor), EO_TYPECHECK(const Eina_List **, list) +#define evas_obj_textblock_node_format_first_get(format) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_FIRST_GET), EO_TYPECHECK(const Evas_Object_Textblock_Node_Format **, format) +#define evas_obj_textblock_node_format_last_get(format) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LAST_GET), EO_TYPECHECK(const Evas_Object_Textblock_Node_Format **, format) +#define evas_obj_textblock_node_format_remove_pair(n) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_REMOVE_PAIR), EO_TYPECHECK(Evas_Object_Textblock_Node_Format *, n) +#define evas_obj_textblock_line_number_geometry_get(line, cx, cy, cw, ch, result) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_LINE_NUMBER_GEOMETRY_GET), EO_TYPECHECK(int, line), EO_TYPECHECK(Evas_Coord *, cx), EO_TYPECHECK(Evas_Coord *, cy), EO_TYPECHECK(Evas_Coord *, cw), EO_TYPECHECK(Evas_Coord *, ch), EO_TYPECHECK(Eina_Bool *, result) +#define evas_obj_textblock_clear() EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_CLEAR) +#define evas_obj_textblock_size_formatted_get(w, h) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_FORMATTED_GET), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) +#define evas_obj_textblock_size_native_get(w, h) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_NATIVE_GET), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) +#define evas_obj_textblock_style_insets_get(l, r, t, b) EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_INSETS_GET), EO_TYPECHECK(Evas_Coord *, l), EO_TYPECHECK(Evas_Coord *, r), EO_TYPECHECK(Evas_Coord *, t), EO_TYPECHECK(Evas_Coord *, b) + /** * Adds a textblock to the given evas. * @param e The given evas. @@ -9318,6 +10179,48 @@ EAPI void evas_object_textblock_style_insets * @{ */ +#define EVAS_OBJ_TEXTGRID_CLASS evas_object_textgrid_class_get() + +const Eo_Class *evas_object_textgrid_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_TEXTGRID_BASE_ID; + +enum +{ + EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_SET, + EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_SET, + EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SET, + EVAS_OBJ_TEXTGRID_SUB_ID_FONT_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_CELL_SIZE_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_SET, + EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_SET, + EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_SET, + EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_GET, + EVAS_OBJ_TEXTGRID_SUB_ID_UPDATE_ADD, + EVAS_OBJ_TEXTGRID_SUB_ID_LAST +}; + +#define EVAS_OBJ_TEXTGRID_ID(sub_id) (EVAS_OBJ_TEXTGRID_BASE_ID + sub_id) + +#define evas_obj_textgrid_size_set(w, h) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_SET), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) +#define evas_obj_textgrid_size_get(w, h) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_GET), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h) +#define evas_obj_textgrid_font_source_set(font_source) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_SET), EO_TYPECHECK(const char *, font_source) +#define evas_obj_textgrid_font_source_get(ret) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_GET), EO_TYPECHECK(const char **, ret) +#define evas_obj_textgrid_font_set(font_name, font_size) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SET), EO_TYPECHECK(const char *, font_name), EO_TYPECHECK(Evas_Font_Size, font_size) +#define evas_obj_textgrid_font_get(font_name, font_size) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_GET), EO_TYPECHECK(const char **, font_name), EO_TYPECHECK(Evas_Font_Size *, font_size) +#define evas_obj_textgrid_cell_size_get(width, height) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_CELL_SIZE_GET), EO_TYPECHECK(int *, width), EO_TYPECHECK(int *, height) +#define evas_obj_textgrid_palette_set(pal, idx, r, g, b, a) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_SET), EO_TYPECHECK(Evas_Textgrid_Palette, pal), EO_TYPECHECK(int, idx), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) +#define evas_obj_textgrid_palette_get(pal, idx, r, g, b, a) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_GET), EO_TYPECHECK(Evas_Textgrid_Palette, pal), EO_TYPECHECK(int, idx), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, g), EO_TYPECHECK(int *, b), EO_TYPECHECK(int *, a) +#define evas_obj_textgrid_supported_font_styles_set(styles) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_SET), EO_TYPECHECK(Evas_Textgrid_Font_Style, styles) +#define evas_obj_textgrid_supported_font_styles_get(ret) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_GET), EO_TYPECHECK(Evas_Textgrid_Font_Style *, ret) +#define evas_obj_textgrid_cellrow_set(y, row) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_SET), EO_TYPECHECK(int, y), EO_TYPECHECK(const Evas_Textgrid_Cell *, row) +#define evas_obj_textgrid_cellrow_get(y, ret) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_GET), EO_TYPECHECK(int, y), EO_TYPECHECK(Evas_Textgrid_Cell **, ret) +#define evas_obj_textgrid_update_add(x, y, w, h) EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_UPDATE_ADD), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) + /** * @typedef Evas_Textgrid_Palette * @@ -9671,6 +10574,23 @@ EAPI void evas_object_textgrid_update_add(Evas_Object *obj, int x, int y, int w, * @{ */ +#define EVAS_OBJ_LINE_CLASS evas_object_line_class_get() +const Eo_Class *evas_object_line_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_LINE_BASE_ID; + +enum +{ + EVAS_OBJ_LINE_SUB_ID_XY_SET, + EVAS_OBJ_LINE_SUB_ID_XY_GET, + EVAS_OBJ_LINE_SUB_ID_LAST +}; + +#define EVAS_OBJ_LINE_ID(sub_id) (EVAS_OBJ_LINE_BASE_ID + sub_id) + +#define evas_obj_line_xy_set(x1, y1, x2, y2) EVAS_OBJ_LINE_ID(EVAS_OBJ_LINE_SUB_ID_XY_SET), EO_TYPECHECK(Evas_Coord, x1), EO_TYPECHECK(Evas_Coord, y1), EO_TYPECHECK(Evas_Coord, x2), EO_TYPECHECK(Evas_Coord, y2) +#define evas_obj_line_xy_get(x1, y1, x2, y2) EVAS_OBJ_LINE_ID(EVAS_OBJ_LINE_SUB_ID_XY_GET), EO_TYPECHECK(Evas_Coord *, x1), EO_TYPECHECK(Evas_Coord *, y1), EO_TYPECHECK(Evas_Coord *, x2), EO_TYPECHECK(Evas_Coord *, y2) + /** * Adds a new evas line object to the given evas. * @param e The given evas. @@ -9721,6 +10641,23 @@ EAPI void evas_object_line_xy_get(const Evas_Object *obj, Evas_Coord *x1 * @{ */ +#define EVAS_OBJ_POLYGON_CLASS evas_object_polygon_class_get() +const Eo_Class *evas_object_polygon_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_POLYGON_BASE_ID; + +enum +{ + EVAS_OBJ_POLYGON_SUB_ID_POINT_ADD, + EVAS_OBJ_POLYGON_SUB_ID_POINTS_CLEAR, + EVAS_OBJ_POLYGON_SUB_ID_LAST +}; + +#define EVAS_OBJ_POLYGON_ID(sub_id) (EVAS_OBJ_POLYGON_BASE_ID + sub_id) + +#define evas_obj_polygon_point_add(x, y) EVAS_OBJ_POLYGON_ID(EVAS_OBJ_POLYGON_SUB_ID_POINT_ADD), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y) +#define evas_obj_polygon_points_clear() EVAS_OBJ_POLYGON_ID(EVAS_OBJ_POLYGON_SUB_ID_POINTS_CLEAR) + /** * Adds a new evas polygon object to the given evas. * @param e The given evas. @@ -10168,6 +11105,248 @@ struct _Evas_Smart_Cb_Description evas_object_smart_data_set(o, priv); \ } +#define EVAS_OBJ_SMART_CLASS evas_object_smart_class_get() + +const Eo_Class *evas_object_smart_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_SMART_BASE_ID; + +enum +{ + EVAS_OBJ_SMART_SUB_ID_DATA_SET, + EVAS_OBJ_SMART_SUB_ID_SMART_GET, + EVAS_OBJ_SMART_SUB_ID_MEMBER_ADD, + EVAS_OBJ_SMART_SUB_ID_MEMBER_DEL, + EVAS_OBJ_SMART_SUB_ID_MEMBERS_GET, + EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_SET, + EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_GET, + EVAS_OBJ_SMART_SUB_ID_CALLBACK_DESCRIPTION_FIND, + EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_SET, + EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_GET, + EVAS_OBJ_SMART_SUB_ID_CALCULATE, + EVAS_OBJ_SMART_SUB_ID_CHANGED, + EVAS_OBJ_SMART_SUB_ID_ATTACH, + // Specific Smart functions that can be overriden by the inherit classes + EVAS_OBJ_SMART_SUB_ID_ADD, + EVAS_OBJ_SMART_SUB_ID_DEL, + EVAS_OBJ_SMART_SUB_ID_RESIZE, + EVAS_OBJ_SMART_SUB_ID_MOVE, + EVAS_OBJ_SMART_SUB_ID_SHOW, + EVAS_OBJ_SMART_SUB_ID_HIDE, + EVAS_OBJ_SMART_SUB_ID_COLOR_SET, + EVAS_OBJ_SMART_SUB_ID_CLIP_SET, + EVAS_OBJ_SMART_SUB_ID_CLIP_UNSET, + EVAS_OBJ_SMART_SUB_ID_LAST +}; + +#define EVAS_OBJ_SMART_ID(sub_id) (EVAS_OBJ_SMART_BASE_ID + sub_id) + +/** + * @def evas_obj_smart_data_set + * + * Store a pointer to user data for a given smart object. + * + * @param[in] data in + * + * @see evas_object_smart_data_set + */ +#define evas_obj_smart_data_set(data) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DATA_SET), EO_TYPECHECK(void *, data) + +/** + * @def evas_obj_smart_smart_get + * + * Get the #Evas_Smart from which smart object was created. + * + * @param[out] smart out + * + * @see evas_object_smart_smart_get + */ +#define evas_obj_smart_smart_get(smart) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SMART_GET), EO_TYPECHECK(Evas_Smart **, smart) + +/** + * @def evas_obj_smart_member_add + * + * Set an Evas object as a member of a given smart object. + * + * @param[in] obj in + * + * @see evas_object_smart_member_add + */ +#define evas_obj_smart_member_add(obj) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBER_ADD), EO_TYPECHECK(Evas_Object *, obj) + +/** + * @def evas_obj_smart_member_del + * + * Removes a member object from a given smart object. + * + * @param[in] obj in + * + * @see evas_object_smart_member_del + */ +#define evas_obj_smart_member_del(obj) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBER_DEL), EO_TYPECHECK(Evas_Object *, obj) + +/** + * @def evas_obj_smart_members_get + * + * Retrieves the list of the member objects of a given Evas smart + * object + * + * @param[out] list out + * + * @see evas_object_smart_members_get + */ +#define evas_obj_smart_members_get(list) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBERS_GET), EO_TYPECHECK(Eina_List **, list) + +/** + * @def evas_obj_smart_callback_priority_add + * + * Add (register) a callback function to the smart event specified by + * @p event on the smart object. Except for the priority field, + * it's exactly the same as @ref evas_object_smart_callback_add + * + * @param[in] event in + * @param[in] priority in + * @param[in] func in + * @param[in] data in + * + * @see evas_object_smart_callback_priority_add + */ +#define evas_obj_smart_callback_priority_add(event, priority, func, data) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACK_PRIORITY_ADD), EO_TYPECHECK(const char *, event), EO_TYPECHECK(Evas_Callback_Priority, priority), EO_TYPECHECK(Evas_Smart_Cb, func), EO_TYPECHECK(const void *, data) + +/** + * @def evas_obj_smart_callback_del + * + * Delete (unregister) a callback function from the smart event + * specified by @p event on the smart object. + * + * @param[in] event in + * @param[in] func in + * @param[out] ret_data out + * + * @see evas_object_smart_callback_del + */ +#define evas_obj_smart_callback_del(event, func, ret_data) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACK_DEL), EO_TYPECHECK(const char *, event), EO_TYPECHECK(Evas_Smart_Cb, func), EO_TYPECHECK(void **, ret_data) + +/** + * @def evas_obj_smart_callback_del_full + * + * Delete (unregister) a callback function from the smart event + * specified by @p event on the smart object. + * + * @param[in] event in + * @param[in] func in + * @param[in] data in + * @param[out] ret_data out + * + * @see evas_object_smart_callback_del_full + */ +#define evas_obj_smart_callback_del_full(event, func, data, ret_data) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACK_DEL_FULL), EO_TYPECHECK(const char *, event), EO_TYPECHECK(Evas_Smart_Cb, func), EO_TYPECHECK(const void *, data), EO_TYPECHECK(void **, ret_data) + +/** + * @def evas_obj_smart_callback_call + * + * Call a given smart callback on the smart object. + * + * @param[in] event + * @param[in] event_info + * + * @see evas_object_smart_callback_call + */ +#define evas_obj_smart_callback_call(event, event_info) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACK_CALL), EO_TYPECHECK(const char *, event), EO_TYPECHECK(void *, event_info) + +/** + * @def evas_obj_smart_callbacks_descriptions_set + * + * Set an smart object @b instance's smart callbacks descriptions. + * + * @param[in] descriptions in + * @param[out] result out + * + * @see evas_object_smart_callbacks_descriptions_set + */ +#define evas_obj_smart_callbacks_descriptions_set(descriptions, result) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_SET), EO_TYPECHECK(const Evas_Smart_Cb_Description *, descriptions), EO_TYPECHECK(Eina_Bool *, result) + +/** + * @def evas_obj_smart_callbacks_descriptions_get + * + * Retrieve an smart object's know smart callback descriptions (both + * instance and class ones). + * + * @param[out] class_descriptions out + * @param[out] class_count out + * @param[out] instance_descriptions out + * @param[out] instance_count out + * + * @see evas_object_smart_callbacks_descriptions_get + */ +#define evas_obj_smart_callbacks_descriptions_get(class_descriptions, class_count, instance_descriptions, instance_count) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_GET), EO_TYPECHECK(const Evas_Smart_Cb_Description ***, class_descriptions), EO_TYPECHECK(unsigned int *, class_count), EO_TYPECHECK(const Evas_Smart_Cb_Description ***, instance_descriptions), EO_TYPECHECK(unsigned int *, instance_count) + +/** + * @def evas_obj_smart_callback_description_find + * + * Find callback description for callback called @a name. + * + * @param[in] name in + * @param[out] class_description out + * @param[out] instance_description out + * + * @see evas_object_smart_callback_description_find + */ +#define evas_obj_smart_callback_description_find(name, class_description, instance_description) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACK_DESCRIPTION_FIND), EO_TYPECHECK(const char *, name), EO_TYPECHECK(const Evas_Smart_Cb_Description **, class_description), EO_TYPECHECK(const Evas_Smart_Cb_Description **, instance_description) + +/** + * @def evas_obj_smart_need_recalculate_set + * + * Set or unset the flag signalling that a given smart object needs to + * get recalculated. + * + * @param[in] value in + * + * @see evas_object_smart_need_recalculate_set + */ +#define evas_obj_smart_need_recalculate_set(value) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_SET), EO_TYPECHECK(Eina_Bool, value) + +/** + * @def evas_obj_smart_need_recalculate_get + * + * Get the value of the flag signalling that a given smart object needs to + * get recalculated. + * + * @param[out] need_recalculate out + * + * @see evas_object_smart_need_recalculate_get + */ +#define evas_obj_smart_need_recalculate_get(need_recalculate) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_GET), EO_TYPECHECK(Eina_Bool *, need_recalculate) + +/** + * @def evas_obj_smart_calculate + * + * Call the @b calculate() smart function immediately on a given smart + * object. + * + * @see evas_object_smart_calculate + */ +#define evas_obj_smart_calculate() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALCULATE) + +/** + * @def evas_obj_smart_changed + * + * Mark smart object as changed, dirty. + * + * @see evas_object_smart_changed + */ +#define evas_obj_smart_changed() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CHANGED) + +#define evas_obj_smart_add() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD) +#define evas_obj_smart_del() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL) +#define evas_obj_smart_resize(w, h) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) +#define evas_obj_smart_move(x, y) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y) +#define evas_obj_smart_show() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SHOW) +#define evas_obj_smart_hide() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_HIDE) +#define evas_obj_smart_color_set(r, g, b, a) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_COLOR_SET), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) +#define evas_obj_smart_clip_set(clip) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CLIP_SET), EO_TYPECHECK(Evas_Object *, clip) +#define evas_obj_smart_clip_unset() EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CLIP_UNSET) + /** * Free an #Evas_Smart struct * @@ -10942,6 +12121,17 @@ EAPI void evas_object_smart_move_children_relative(Evas_Object *obj, Eva * @{ */ +#define EVAS_OBJ_SMART_CLIPPED_CLASS evas_object_smart_clipped_eo_class_get() + +const Eo_Class *evas_object_smart_clipped_eo_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_SMART_CLIPPED_BASE_ID; + +enum +{ + EVAS_OBJ_SMART_CLIPPED_SUB_ID_LAST +}; + /** * Every subclass should provide this at the beginning of their own * data set with evas_object_smart_data_set(). @@ -11265,6 +12455,98 @@ struct _Evas_Object_Box_Option Evas_Coord alloc_size; }; /**< #Evas_Object_Box_Option struct fields */ +#define EVAS_OBJ_BOX_CLASS evas_object_box_class_get() + +const Eo_Class *evas_object_box_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_BOX_BASE_ID; + +enum +{ + EVAS_OBJ_BOX_SUB_ID_INTERNAL_APPEND, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_PREPEND, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_BEFORE, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AFTER, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AT, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE_AT, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_NEW, + EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_FREE, + + EVAS_OBJ_BOX_SUB_ID_ADD_TO, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_SET, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_HORIZONTAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_VERTICAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_HORIZONTAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_VERTICAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_HORIZONTAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_VERTICAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_HORIZONTAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_VERTICAL, + EVAS_OBJ_BOX_SUB_ID_LAYOUT_STACK, + EVAS_OBJ_BOX_SUB_ID_ALIGN_SET, + EVAS_OBJ_BOX_SUB_ID_ALIGN_GET, + EVAS_OBJ_BOX_SUB_ID_PADDING_SET, + EVAS_OBJ_BOX_SUB_ID_PADDING_GET, + EVAS_OBJ_BOX_SUB_ID_APPEND, + EVAS_OBJ_BOX_SUB_ID_PREPEND, + EVAS_OBJ_BOX_SUB_ID_INSERT_BEFORE, + EVAS_OBJ_BOX_SUB_ID_INSERT_AFTER, + EVAS_OBJ_BOX_SUB_ID_INSERT_AT, + EVAS_OBJ_BOX_SUB_ID_REMOVE, + EVAS_OBJ_BOX_SUB_ID_REMOVE_AT, + EVAS_OBJ_BOX_SUB_ID_REMOVE_ALL, + EVAS_OBJ_BOX_SUB_ID_ITERATOR_NEW, + EVAS_OBJ_BOX_SUB_ID_ACCESSOR_NEW, + EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_NAME_GET, + EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_ID_GET, + EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VSET, + EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VGET, + EVAS_OBJ_BOX_SUB_ID_LAST +}; + +#define EVAS_OBJ_BOX_ID(sub_id) (EVAS_OBJ_BOX_BASE_ID + sub_id) + +#define evas_obj_box_internal_append(child, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_APPEND), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_internal_prepend(child, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_PREPEND), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_internal_insert_before(child, reference, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_BEFORE), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(const Evas_Object *, reference), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_internal_insert_after(child, reference, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AFTER), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(const Evas_Object *, reference), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_internal_insert_at(child, pos, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AT), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(unsigned int, pos), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_internal_remove(child, result) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Evas_Object **, result) +#define evas_obj_box_internal_remove_at(pos, result) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE_AT), EO_TYPECHECK(unsigned int, pos), EO_TYPECHECK(Evas_Object **, result) +#define evas_obj_box_internal_option_new(child, ret) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_NEW), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Evas_Object_Box_Option **, ret) +#define evas_obj_box_internal_option_free(opt) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_FREE), EO_TYPECHECK(Evas_Object_Box_Option *, opt) + +#define evas_obj_box_add_to(o) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ADD_TO), EO_TYPECHECK(Evas_Object **, o) +#define evas_obj_box_layout_set(cb, data, free_data) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_SET), EO_TYPECHECK(Evas_Object_Box_Layout, cb), EO_TYPECHECK(const void *, data), EO_TYPECHECK(Eina_Free_Cb, free_data) +#define evas_obj_box_layout_horizontal() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HORIZONTAL) +#define evas_obj_box_layout_vertical() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_VERTICAL) +#define evas_obj_box_layout_homogeneous_horizontal() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_HORIZONTAL) +#define evas_obj_box_layout_homogeneous_vertical() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_VERTICAL) +#define evas_obj_box_layout_homogeneous_max_size_horizontal() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_HORIZONTAL) +#define evas_obj_box_layout_homogeneous_max_size_vertical() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_VERTICAL) +#define evas_obj_box_layout_flow_horizontal() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_HORIZONTAL) +#define evas_obj_box_layout_flow_vertical() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_VERTICAL) +#define evas_obj_box_layout_stack() EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_STACK) +#define evas_obj_box_align_set(horizontal, vertical) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ALIGN_SET), EO_TYPECHECK(double, horizontal), EO_TYPECHECK(double, vertical) +#define evas_obj_box_align_get(horizontal, vertical) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ALIGN_GET), EO_TYPECHECK(double *, horizontal), EO_TYPECHECK(double *, vertical) +#define evas_obj_box_padding_set(horizontal, vertical) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_PADDING_SET), EO_TYPECHECK(Evas_Coord, horizontal), EO_TYPECHECK(Evas_Coord, vertical) +#define evas_obj_box_padding_get(horizontal, vertical) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_PADDING_GET), EO_TYPECHECK(Evas_Coord *, horizontal), EO_TYPECHECK(Evas_Coord *, vertical) +#define evas_obj_box_append(child, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_APPEND), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_prepend(child, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_PREPEND), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_insert_before(child, reference, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INSERT_BEFORE), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(const Evas_Object *, reference), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_insert_after(child, reference, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INSERT_AFTER), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(const Evas_Object *, reference), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_insert_at(child, pos, option) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INSERT_AT), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(unsigned int, pos), EO_TYPECHECK(Evas_Object_Box_Option **, option) +#define evas_obj_box_remove(child, result) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_REMOVE), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Eina_Bool *, result) +#define evas_obj_box_remove_at(pos, result) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_REMOVE_AT), EO_TYPECHECK(unsigned int, pos), EO_TYPECHECK(Eina_Bool *, result) +#define evas_obj_box_remove_all(clear, result) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_REMOVE_ALL), EO_TYPECHECK(Eina_Bool, clear), EO_TYPECHECK(Eina_Bool *, result) +#define evas_obj_box_iterator_new(itr) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ITERATOR_NEW), EO_TYPECHECK(Eina_Iterator **, itr) +#define evas_obj_box_accessor_new(accessor) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ACCESSOR_NEW), EO_TYPECHECK(Eina_Accessor **, accessor) +#define evas_obj_box_option_property_name_get(property, name) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_NAME_GET), EO_TYPECHECK(int, property), EO_TYPECHECK(const char **, name) +#define evas_obj_box_option_property_id_get(name, id) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_ID_GET), EO_TYPECHECK(const char *, name), EO_TYPECHECK(int *, id) +#define evas_obj_box_option_property_vset(opt, property, args, ret) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VSET), EO_TYPECHECK(Evas_Object_Box_Option *, opt), EO_TYPECHECK(int, property), EO_TYPECHECK(va_list, args), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_box_option_property_vget(opt, property, args, ret) EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VGET), EO_TYPECHECK(Evas_Object_Box_Option *, opt), EO_TYPECHECK(int, property), EO_TYPECHECK(va_list, args), EO_TYPECHECK(Eina_Bool *, ret) + /** * Set the default box @a api struct (Evas_Object_Box_Api) * with the default values. May be used to extend that API. @@ -12009,6 +13291,54 @@ EAPI Eina_Bool evas_object_box_option_property_vget(const Evas_ * @{ */ +#define EVAS_OBJ_TABLE_CLASS evas_object_table_class_get() + +const Eo_Class *evas_object_table_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_TABLE_BASE_ID; + +enum +{ + EVAS_OBJ_TABLE_SUB_ID_ADD_TO, + EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_SET, + EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_GET, + EVAS_OBJ_TABLE_SUB_ID_ALIGN_SET, + EVAS_OBJ_TABLE_SUB_ID_ALIGN_GET, + EVAS_OBJ_TABLE_SUB_ID_PADDING_SET, + EVAS_OBJ_TABLE_SUB_ID_PADDING_GET, + EVAS_OBJ_TABLE_SUB_ID_PACK_GET, + EVAS_OBJ_TABLE_SUB_ID_PACK, + EVAS_OBJ_TABLE_SUB_ID_UNPACK, + EVAS_OBJ_TABLE_SUB_ID_CLEAR, + EVAS_OBJ_TABLE_SUB_ID_COL_ROW_SIZE_GET, + EVAS_OBJ_TABLE_SUB_ID_ITERATOR_NEW, + EVAS_OBJ_TABLE_SUB_ID_ACCESSOR_NEW, + EVAS_OBJ_TABLE_SUB_ID_CHILDREN_GET, + EVAS_OBJ_TABLE_SUB_ID_MIRRORED_GET, + EVAS_OBJ_TABLE_SUB_ID_MIRRORED_SET, + EVAS_OBJ_TABLE_SUB_ID_LAST +}; + +#define EVAS_OBJ_TABLE_ID(sub_id) (EVAS_OBJ_TABLE_BASE_ID + sub_id) + +#define evas_obj_table_add_to(ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ADD_TO), EO_TYPECHECK(Evas_Object **, ret) +#define evas_obj_table_homogeneous_set(homogeneous) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_SET), EO_TYPECHECK(Evas_Object_Table_Homogeneous_Mode, homogeneous) +#define evas_obj_table_homogeneous_get(ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_GET), EO_TYPECHECK(Evas_Object_Table_Homogeneous_Mode *, ret) +#define evas_obj_table_align_set(horizontal, vertical) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ALIGN_SET), EO_TYPECHECK(double, horizontal), EO_TYPECHECK(double, vertical) +#define evas_obj_table_align_get(horizontal, vertical) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ALIGN_GET), EO_TYPECHECK(double *, horizontal), EO_TYPECHECK(double *, vertical) +#define evas_obj_table_padding_set(horizontal, vertical) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PADDING_SET), EO_TYPECHECK(Evas_Coord, horizontal), EO_TYPECHECK(Evas_Coord, vertical) +#define evas_obj_table_padding_get(horizontal, vertical) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PADDING_GET), EO_TYPECHECK(Evas_Coord *, horizontal), EO_TYPECHECK(Evas_Coord *, vertical) +#define evas_obj_table_pack_get(child, col, row, colspan, rowspan, ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PACK_GET), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(unsigned short *, col), EO_TYPECHECK(unsigned short *, row), EO_TYPECHECK(unsigned short *, colspan), EO_TYPECHECK(unsigned short *, rowspan), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_table_pack(child, col, row, colspan, rowspan, ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PACK), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(unsigned short, col), EO_TYPECHECK(unsigned short, row), EO_TYPECHECK(unsigned short, colspan), EO_TYPECHECK(unsigned short, rowspan), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_table_unpack(child, ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_UNPACK), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_table_clear(clear) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_CLEAR), EO_TYPECHECK(Eina_Bool, clear) +#define evas_obj_table_col_row_size_get(cols, rows) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_COL_ROW_SIZE_GET), EO_TYPECHECK(int *, cols), EO_TYPECHECK(int *, rows) +#define evas_obj_table_iterator_new(ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ITERATOR_NEW), EO_TYPECHECK(Eina_Iterator **, ret) +#define evas_obj_table_accessor_new(ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ACCESSOR_NEW), EO_TYPECHECK(Eina_Accessor **, ret) +#define evas_obj_table_children_get(ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_CHILDREN_GET), EO_TYPECHECK(Eina_List **, ret) +#define evas_obj_table_mirrored_get(ret) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_MIRRORED_GET), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_table_mirrored_set(mirrored) EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_MIRRORED_SET), EO_TYPECHECK(Eina_Bool, mirrored) + /** * @brief Create a new table. * @@ -12223,6 +13553,45 @@ EAPI Evas_Object *evas_object_table_child_get(const Evas_O * @{ */ +#define EVAS_OBJ_GRID_CLASS evas_object_grid_class_get() + +const Eo_Class *evas_object_grid_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_GRID_BASE_ID; + +enum +{ + EVAS_OBJ_GRID_SUB_ID_ADD_TO, + EVAS_OBJ_GRID_SUB_ID_SIZE_SET, + EVAS_OBJ_GRID_SUB_ID_SIZE_GET, + EVAS_OBJ_GRID_SUB_ID_PACK, + EVAS_OBJ_GRID_SUB_ID_UNPACK, + EVAS_OBJ_GRID_SUB_ID_CLEAR, + EVAS_OBJ_GRID_SUB_ID_PACK_GET, + EVAS_OBJ_GRID_SUB_ID_ITERATOR_NEW, + EVAS_OBJ_GRID_SUB_ID_ACCESSOR_NEW, + EVAS_OBJ_GRID_SUB_ID_CHILDREN_GET, + EVAS_OBJ_GRID_SUB_ID_MIRRORED_GET, + EVAS_OBJ_GRID_SUB_ID_MIRRORED_SET, + EVAS_OBJ_GRID_SUB_ID_LAST +}; + +#define EVAS_OBJ_GRID_ID(sub_id) (EVAS_OBJ_GRID_BASE_ID + sub_id) + +#define evas_obj_grid_add(ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ADD), EO_TYPECHECK(Evas_Object **, ret) +#define evas_obj_grid_add_to(ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ADD_TO), EO_TYPECHECK(Evas_Object **, ret) +#define evas_obj_grid_size_set(w, h) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_SIZE_SET), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) +#define evas_obj_grid_size_get(w, h) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_SIZE_GET), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h) +#define evas_obj_grid_pack(child, x, y, w, h, ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_PACK), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_grid_unpack(child, ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_UNPACK), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_grid_clear(clear) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_CLEAR), EO_TYPECHECK(Eina_Bool, clear) +#define evas_obj_grid_pack_get(child, x, y, w, h, ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_PACK_GET), EO_TYPECHECK(Evas_Object *, child), EO_TYPECHECK(int *, x), EO_TYPECHECK(int *, y), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_grid_iterator_new(ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ITERATOR_NEW), EO_TYPECHECK(Eina_Iterator **, ret) +#define evas_obj_grid_accessor_new(ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ACCESSOR_NEW), EO_TYPECHECK(Eina_Accessor **, ret) +#define evas_obj_grid_children_get(ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_CHILDREN_GET), EO_TYPECHECK(Eina_List **, ret) +#define evas_obj_grid_mirrored_get(ret) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_MIRRORED_GET), EO_TYPECHECK(Eina_Bool *, ret) +#define evas_obj_grid_mirrored_set(mirrored) EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_MIRRORED_SET), EO_TYPECHECK(Eina_Bool, mirrored) + /** * Create a new grid. * @@ -13215,6 +14584,1850 @@ EAPI Evas_Touch_Point_State evas_touch_point_list_nth_state_get(Evas *e, unsigne * @} */ +#define EVAS_COMMON_CLASS evas_common_class_get() + +const Eo_Class *evas_common_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_COMMON_BASE_ID; + +enum +{ + EVAS_COMMON_SUB_ID_EVAS_GET, + EVAS_COMMON_SUB_ID_LAST +}; + +#define EVAS_COMMON_ID(sub_id) (EVAS_COMMON_BASE_ID + sub_id) + +#define evas_common_evas_get(ret) EVAS_COMMON_ID(EVAS_COMMON_SUB_ID_EVAS_GET), EO_TYPECHECK(Evas **, ret) + +extern EAPI Eo_Op EVAS_OBJ_BASE_ID; + +enum +{ + EVAS_OBJ_SUB_ID_POSITION_SET, + EVAS_OBJ_SUB_ID_POSITION_GET, + EVAS_OBJ_SUB_ID_SIZE_SET, + EVAS_OBJ_SUB_ID_SIZE_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_GET, + EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_SET, + EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_GET, + EVAS_OBJ_SUB_ID_VISIBILITY_SET, + EVAS_OBJ_SUB_ID_VISIBILITY_GET, + EVAS_OBJ_SUB_ID_COLOR_SET, + EVAS_OBJ_SUB_ID_COLOR_GET, + EVAS_OBJ_SUB_ID_ANTI_ALIAS_SET, + EVAS_OBJ_SUB_ID_ANTI_ALIAS_GET, + EVAS_OBJ_SUB_ID_SCALE_SET, + EVAS_OBJ_SUB_ID_SCALE_GET, + EVAS_OBJ_SUB_ID_RENDER_OP_SET, + EVAS_OBJ_SUB_ID_RENDER_OP_GET, + EVAS_OBJ_SUB_ID_TYPE_SET, + EVAS_OBJ_SUB_ID_TYPE_GET, + EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_SET, + EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_GET, + EVAS_OBJ_SUB_ID_STATIC_CLIP_SET, + EVAS_OBJ_SUB_ID_STATIC_CLIP_GET, + EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_SET, + EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_GET, + EVAS_OBJ_SUB_ID_FREEZE_EVENTS_SET, + EVAS_OBJ_SUB_ID_FREEZE_EVENTS_GET, + EVAS_OBJ_SUB_ID_PASS_EVENTS_SET, + EVAS_OBJ_SUB_ID_PASS_EVENTS_GET, + EVAS_OBJ_SUB_ID_REPEAT_EVENTS_SET, + EVAS_OBJ_SUB_ID_REPEAT_EVENTS_GET, + EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_SET, + EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_GET, + EVAS_OBJ_SUB_ID_POINTER_MODE_SET, + EVAS_OBJ_SUB_ID_POINTER_MODE_GET, + EVAS_OBJ_SUB_ID_KEY_GRAB, + EVAS_OBJ_SUB_ID_KEY_UNGRAB, + EVAS_OBJ_SUB_ID_FOCUS_SET, + EVAS_OBJ_SUB_ID_FOCUS_GET, + EVAS_OBJ_SUB_ID_NAME_SET, + EVAS_OBJ_SUB_ID_NAME_GET, + EVAS_OBJ_SUB_ID_NAME_CHILD_FIND, + EVAS_OBJ_SUB_ID_LAYER_SET, + EVAS_OBJ_SUB_ID_LAYER_GET, + EVAS_OBJ_SUB_ID_CLIP_SET, + EVAS_OBJ_SUB_ID_CLIP_GET, + EVAS_OBJ_SUB_ID_CLIP_UNSET, + EVAS_OBJ_SUB_ID_CLIPEES_GET, + EVAS_OBJ_SUB_ID_MAP_ENABLE_SET, + EVAS_OBJ_SUB_ID_MAP_ENABLE_GET, + EVAS_OBJ_SUB_ID_MAP_SET, + EVAS_OBJ_SUB_ID_MAP_GET, + EVAS_OBJ_SUB_ID_SMART_PARENT_GET, + EVAS_OBJ_SUB_ID_SMART_DATA_GET, + EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK, + EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK_PTR, + EVAS_OBJ_SUB_ID_SMART_MOVE_CHILDREN_RELATIVE, + EVAS_OBJ_SUB_ID_SMART_CLIPPED_CLIPPER_GET, + EVAS_OBJ_SUB_ID_RAISE, + EVAS_OBJ_SUB_ID_LOWER, + EVAS_OBJ_SUB_ID_STACK_ABOVE, + EVAS_OBJ_SUB_ID_STACK_BELOW, + EVAS_OBJ_SUB_ID_ABOVE_GET, + EVAS_OBJ_SUB_ID_BELOW_GET, + EVAS_OBJ_SUB_ID_TYPE_CHECK, + EVAS_OBJ_SUB_ID_LAST +}; + +#define EVAS_OBJ_ID(sub_id) (EVAS_OBJ_BASE_ID + sub_id) + +/** + * @def evas_obj_position_set + * + * Move the given Evas object to the given location inside its + * canvas' viewport. + * + * @param[in] x in + * @param[in] y in + * + * @see evas_object_move + */ +#define evas_obj_position_set(x, y) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POSITION_SET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y) + +/** + * @def evas_obj_position_get + * + * Retrieves the position of the given Evas object. + * + * @param[out] x out + * @param[out] y out + * + * @see evas_object_geometry_get + */ +#define evas_obj_position_get(x, y) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POSITION_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y) + +/** + * @def evas_obj_size_set + * Changes the size of the given Evas object. + * + * @param w[in] in + * @param h[in] in + * + * @see evas_object_resize + */ +#define evas_obj_size_set(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_SET), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) + +/** + * @def evas_obj_size_get + * + * Retrieves the (rectangular) size of the given Evas object. + * + * @param[out] w out + * @param[out] h out + * + * @see evas_object_geometry_get + */ +#define evas_obj_size_get(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_GET), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) + +/** + * @def evas_obj_size_hint_min_set + * + * Sets the hints for an object's minimum size. + * + * @param[in] w in + * @param[in] h in + * + * @see evas_object_size_hint_min_set + */ +#define evas_obj_size_hint_min_set(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_SET), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) + +/** + * @def evas_obj_size_hint_min_get + * + * Retrieves the hints for an object's minimum size. + * + * @param[out] w out + * @param[out] h out + * + * @see evas_object_size_hint_min_get + */ +#define evas_obj_size_hint_min_get(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_GET), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) + +/** + * @def evas_obj_size_hint_max_set + * + * Sets the hints for an object's maximum size. + * + * @param[in] w in + * @param[in] h in + * + * @see evas_object_size_hint_max_set + */ +#define evas_obj_size_hint_max_set(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_SET), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) + +/** + * @def evas_obj_size_hint_max_get + * + * Retrieves the hints for an object's maximum size. + * + * @param[out] w out + * @param[out] h out + * + * @see evas_object_size_hint_max_get + */ +#define evas_obj_size_hint_max_get(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_GET), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) + +/** + * @def evas_obj_size_hint_request_set + * + * Sets the hints for an object's optimum size. + * + * @param[in] w in + * @param[in] h in + * + * @see evas_object_size_hint_request_set + */ +#define evas_obj_size_hint_request_set(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_SET), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) + +/** + * @def evas_obj_size_hint_request_get + * + * Retrieves the hints for an object's optimum size. + * + * @param[out] w out + * @param[out] h out + * + * @see evas_object_size_hint_request_get + */ +#define evas_obj_size_hint_request_get(w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_GET), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) + +/** + * @def evas_obj_size_hint_aspect_set + * + * Sets the hints for an object's aspect ratio. + * + * @param[in] aspect in + * @param[in] w in + * @param[in] h in + * + * @see evas_object_size_hint_aspect_set + */ +#define evas_obj_size_hint_aspect_set(aspect, w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_SET), EO_TYPECHECK(Evas_Aspect_Control, aspect), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) + +/** + * @def evas_obj_size_hint_aspect_get + * + * Retrieves the hints for an object's aspect ratio. + * + * @param[out] aspect out + * @param[out] w out + * @param[out] h out + * + * @see evas_object_size_hint_aspect_get + */ +#define evas_obj_size_hint_aspect_get(aspect, w, h) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_GET), EO_TYPECHECK(Evas_Aspect_Control *, aspect), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) + +/** + * @def evas_obj_size_hint_align_set + * + * Sets the hints for an object's alignment. + * + * @param[in] x in + * @param[in] y in + * + * @see evas_object_size_hint_align_set + */ +#define evas_obj_size_hint_align_set(x, y) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_SET), EO_TYPECHECK(double, x), EO_TYPECHECK(double, y) + +/** + * @def evas_obj_size_hint_align_get + * + * Retrieves the hints for on object's alignment. + * + * @param[out] x out + * @param[out] y out + * + * @see evas_object_size_hint_align_get + */ +#define evas_obj_size_hint_align_get(x, y) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_GET), EO_TYPECHECK(double *, x), EO_TYPECHECK(double *, y) + +/** + * @def evas_obj_size_hint_weight_set + * + * Sets the hints for an object's weight. + * + * @param[in] x in + * @param[in] y in + * + * @see evas_object_size_hint_weight_set + */ +#define evas_obj_size_hint_weight_set(x, y) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_SET), EO_TYPECHECK(double, x), EO_TYPECHECK(double, y) + +/** + * @def evas_obj_size_hint_weight_get + * + * Retrieves the hints for an object's weight. + * + * @param[out] x out + * @param[out] y out + * + * @see evas_object_size_hint_weight_get + */ +#define evas_obj_size_hint_weight_get(x, y) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_GET), EO_TYPECHECK(double *, x), EO_TYPECHECK(double *, y) + +/** + * @def evas_obj_size_hint_padding_set + * + * Sets the hints for an object's padding space. + * + * @param[in] l in + * @param[in] r in + * @param[in] t in + * @param[in] b in + * + * @see evas_object_size_hint_padding_set + */ +#define evas_obj_size_hint_padding_set(l, r, t, b) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_SET), EO_TYPECHECK(Evas_Coord, l), EO_TYPECHECK(Evas_Coord, r), EO_TYPECHECK(Evas_Coord, t), EO_TYPECHECK(Evas_Coord, b) + +/** + * @def evas_obj_size_hint_padding_get + * + * Retrieves the hints for an object's padding space. + * + * @param[out] l out + * @param[out] r out + * @param[out] t out + * @param[out] b out + * + * @see evas_object_size_hint_padding_get + */ +#define evas_obj_size_hint_padding_get(l, r, t, b) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_GET), EO_TYPECHECK(Evas_Coord *, l), EO_TYPECHECK(Evas_Coord *, r), EO_TYPECHECK(Evas_Coord *, t), EO_TYPECHECK(Evas_Coord *, b) + +/** + * @def evas_obj_visibility_set + * + * Makes the given Evas object visible or invisible. + * @param[in] v @c EINA_TRUE if to make the object visible, @c EINA_FALSE + * otherwise. + * + * @see evas_object_show + * @see evas_object_hide + */ +#define evas_obj_visibility_set(v) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_VISIBILITY_SET), EO_TYPECHECK(Eina_Bool, v) + +/** + * @def evas_obj_visibility_get + * + * Retrieves whether or not the given Evas object is visible. + * + * @param[out] v @c EINA_TRUE if the object is visible, @c EINA_FALSE + * otherwise. + * + * @see evas_object_visible_get + */ +#define evas_obj_visibility_get(v) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_VISIBILITY_GET), EO_TYPECHECK(Eina_Bool *, v) + +/** + * @def evas_obj_color_set + * + * Sets the general/main color of the given Evas object to the given + * one. + * + * @param[in] r in + * @param[in] g in + * @param[in] b in + * @param[in] a in + * + * @see evas_object_color_set + */ +#define evas_obj_color_set(r, g, b, a) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_COLOR_SET), EO_TYPECHECK(int, r), EO_TYPECHECK(int, g), EO_TYPECHECK(int, b), EO_TYPECHECK(int, a) + +/** + * @def evas_obj_color_get + * Retrieves the general/main color of the given Evas object. + * + * @param r out + * @param g out + * @param b out + * @param a out + * + * @see evas_object_color_get + */ +#define evas_obj_color_get(r, g, b, a) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_COLOR_GET), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, g), EO_TYPECHECK(int *, b), EO_TYPECHECK(int *, a) + +/** + * @def evas_obj_anti_alias_set + * + * Sets whether or not the given Evas object is to be drawn anti-aliased. + * + * @param[in] anti_alias in + * + * @see evas_object_anti_alias_set + */ +#define evas_obj_anti_alias_set(anti_alias) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_ANTI_ALIAS_SET), EO_TYPECHECK(Eina_Bool, anti_alias) + +/** + * @def evas_obj_anti_alias_get + * + * Retrieves whether or not the given Evas object is to be drawn anti_aliased. + * + * @param[out] anti_alias out + * + * @see evas_object_anti_alias_get + */ +#define evas_obj_anti_alias_get(anti_alias) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_ANTI_ALIAS_GET), EO_TYPECHECK(Eina_Bool *, anti_alias) + +/** + * @def evas_obj_scale_set + * + * Sets the scaling factor for an Evas object. Does not affect all + * objects. + * + * @param[in] scale in + * + * @see evas_object_scale_set + */ +#define evas_obj_scale_set(scale) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SCALE_SET), EO_TYPECHECK(double, scale) + +/** + * @def evas_obj_scale_get + * + * Retrieves the scaling factor for the given Evas object. + * + * @param[out] scale out + * + * @see evas_object_scale_get + */ +#define evas_obj_scale_get(scale) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SCALE_GET), EO_TYPECHECK(double *, scale) + +/** + * @def evas_obj_render_op_set + * + * Sets the render_op to be used for rendering the Evas object. + * + * @param[in] render_op in + * + * @see evas_object_render_op_set + */ +#define evas_obj_render_op_set(render_op) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_RENDER_OP_SET), EO_TYPECHECK(Evas_Render_Op, render_op) + +/** + * @def evas_obj_render_op_get + * + * Retrieves the current value of the operation used for rendering the Evas object. + * + * @param[out] render_op + * + * @see evas_object_render_op_get + */ +#define evas_obj_render_op_get(render_op) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_RENDER_OP_GET), EO_TYPECHECK(Evas_Render_Op *, render_op) + +/** + * @def evas_obj_evas_get + * Retrieves the Evas canvas that the given object lives on. + * + * @param[out] out. + * @see evas_object_evas_get + */ +#define evas_obj_evas_get(evas) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_EVAS_GET), EO_TYPECHECK(Evas **, evas) + +/** + * @def evas_obj_type_get + * Retrieves the type of the given Evas object. + * + * @param[out] type out + * @see evas_object_type_get + */ +#define evas_obj_type_get(type) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_GET), EO_TYPECHECK(const char **, type) + +/** + * @def evas_obj_type_set + * Sets the type of the given Evas object. + * + * @param[in] type in + */ +#define evas_obj_type_set(type) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_SET), EO_TYPECHECK(const char *, type) + +/** + * @def evas_obj_precise_is_inside_set + * + * Set whether to use precise (usually expensive) point collision + * detection for a given Evas object. + * + * @param[in] precise in + * + * @see evas_object_precise_is_inside_set + */ +#define evas_obj_precise_is_inside_set(precise) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_SET), EO_TYPECHECK(Eina_Bool, precise) + +/** + * @def evas_obj_precise_is_inside_get + * + * Determine whether an object is set to use precise point collision + * detection. + * + * @param[out] precise out + * + * @see evas_object_precise_is_inside_get + */ +#define evas_obj_precise_is_inside_get(precise) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_GET), EO_TYPECHECK(Eina_Bool *, precise) + +/** + * @def evas_obj_static_clip_set + * + * Set a hint flag on the given Evas object that it's used as a "static + * clipper". + * + * @param[in] is_static_clip in + * + * @see evas_object_static_clip_set + */ +#define evas_obj_static_clip_set(is_static_clip) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STATIC_CLIP_SET), EO_TYPECHECK(Eina_Bool, is_static_clip) + +/** + * @def evas_obj_static_clip_get + * + * Get the "static clipper" hint flag for a given Evas object. + * + * @param[out] is_static_clip out + * + * @see evas_object_static_clip_get + */ +#define evas_obj_static_clip_get(is_static_clip) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STATIC_CLIP_GET), EO_TYPECHECK(Eina_Bool *, is_static_clip) + +/** + * @def evas_obj_is_frame_object_set + * + * @param[in] is_frame in + * + * @see evas_object_is_frame_object_set + */ +#define evas_obj_is_frame_object_set(is_frame) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_SET), EO_TYPECHECK(Eina_Bool, is_frame) + +/** + * @def evas_obj_is_frame_object_get + * + * @param[out] is_frame out + * + * @see evas_object_is_frame_object_get + */ +#define evas_obj_is_frame_object_get(is_frame) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_GET), EO_TYPECHECK(Eina_Bool *, is_frame) + +/** + * @def evas_obj_freeze_events_set + * + * Set whether an Evas object is to freeze (discard) events. + * + * @param[in] freeze in + * + * @see evas_object_freeze_events_set + */ +#define evas_obj_freeze_events_set(freeze) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FREEZE_EVENTS_SET), EO_TYPECHECK(Eina_Bool, freeze) + +/** + * @def evas_obj_freeze_events_get + * + * Determine whether an object is set to freeze (discard) events. + * + * @param[out] freeze out + * + * @see evas_object_freeze_events_get + */ +#define evas_obj_freeze_events_get(freeze) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FREEZE_EVENTS_GET), EO_TYPECHECK(Eina_Bool *, freeze) + +/** + * @def evas_obj_pass_events_set + * + * Set whether an Evas object is to pass (ignore) events. + * + * @param[in] pass in + * + * @see evas_object_pass_events_set + */ +#define evas_obj_pass_events_set(pass) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PASS_EVENTS_SET), EO_TYPECHECK(Eina_Bool, pass) + +/** + * @def evas_obj_pass_events_get + * + * Determine whether an object is set to pass (ignore) events. + * + * @param[out] pass + * + * @see evas_object_pass_events_get + */ +#define evas_obj_pass_events_get(pass) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PASS_EVENTS_GET), EO_TYPECHECK(Eina_Bool *, pass) + +/** + * @def evas_obj_repeat_events_set + * + * Set whether an Evas object is to repeat events. + * + * @param[in] repeat in + * + * @see evas_object_repeat_events_set + */ +#define evas_obj_repeat_events_set(repeat) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_REPEAT_EVENTS_SET), EO_TYPECHECK(Eina_Bool, repeat) + +/** + * @def evas_obj_repeat_events_get + * + * Determine whether an object is set to repeat events. + * + * @param[out] repeat out + * + * @see evas_object_repeat_events_get + */ +#define evas_obj_repeat_events_get(repeat) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_REPEAT_EVENTS_GET), EO_TYPECHECK(Eina_Bool *, repeat) + +/** + * @def evas_obj_propagate_events_set + * + * Set whether events on a smart object's member should get propagated + * up to its parent. + * + * @param[in] propagate in + * @see evas_object_propagate_events_set + */ +#define evas_obj_propagate_events_set(propagate) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_SET), EO_TYPECHECK(Eina_Bool, propagate) + +/** + * @def evas_obj_propagate_events_get + * + * Retrieve whether an Evas object is set to propagate events. + * + * @param[out] propagate out + * + * @see evas_object_propagate_events_get + */ +#define evas_obj_propagate_events_get(propagate) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_GET), EO_TYPECHECK(Eina_Bool *, propagate) + +/** + * @def evas_obj_pointer_mode_set + * + * Set pointer behavior. + * + * @param[in] setting in + * + * @see evas_object_pointer_mode_set + */ +#define evas_obj_pointer_mode_set(pointer_mode) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POINTER_MODE_SET), EO_TYPECHECK(Evas_Object_Pointer_Mode, pointer_mode) + +/** + * @def evas_obj_pointer_mode_get + * + * Determine how pointer will behave. + * + * @param[out] setting out + * + * @see evas_object_pointer_mode_get + */ +#define evas_obj_pointer_mode_get(pointer_mode) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POINTER_MODE_GET), EO_TYPECHECK(Evas_Object_Pointer_Mode *, pointer_mode) + +/** + * @def evas_obj_clip_set + * Clip one object to another. + * + * @parami[in] clip in + * + * @see evas_object_clip_set + */ +#define evas_obj_clip_set(clip) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIP_SET), EO_TYPECHECK(Evas_Object *, clip) + +/** + * @def evas_obj_clip_get + * Get the object clipping @p obj (if any). + * + * @param[out] clip out + * + * @see evas_object_clip_get + */ +#define evas_obj_clip_get(clip) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIP_GET), EO_TYPECHECK(Evas_Object **, clip) + +/** + * @def evas_obj_clip_unset + * Disable/cease clipping on a clipped @p obj object. + * + * @see evas_object_clip_unset + */ +#define evas_obj_clip_unset() EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIP_UNSET) + +/** + * @def evas_obj_clipees_get + * Return a list of objects currently clipped by @p obj. + * + * @param[out] clipees out + * + * @see evas_object_clipees_get + */ +#define evas_obj_clipees_get(clipees) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIPEES_GET), EO_TYPECHECK(const Eina_List **, clipees) + +/** + * @def evas_obj_focus_set + * Sets or unsets a given object as the currently focused one on its + * canvas. + * @param[in] focus in + * + * @see evas_object_focus_set + */ +#define evas_obj_focus_set(focus) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FOCUS_SET), EO_TYPECHECK(Eina_Bool, focus) + +/** + * @def evas_obj_focus_get + * Retrieve whether an object has the focus. + * + * @param[out] focus out + * + * @see evas_object_focus_get + */ +#define evas_obj_focus_get(focus) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FOCUS_GET), EO_TYPECHECK(Eina_Bool *, focus) + +/** + * @def evas_obj_name_set + * Sets the name of the given Evas object to the given name. + * + * @param[in] name in + * + * @see evas_object_name_set + */ +#define evas_obj_name_set(name) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_NAME_SET), EO_TYPECHECK(const char *, name) + +/** + * @def evas_obj_name_get + * + * Retrieves the name of the given Evas object. + * + * @param[out] name out + * + * @see evas_object_name_get + * + */ +#define evas_obj_name_get(name) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_NAME_GET), EO_TYPECHECK(const char **, name) + +/** + * @def evas_obj_name_child_find + * + * Retrieves the object from children of the given object with the given name. + * @param[in] name in + * @param[in] recurse in + * @param[out] child out + * + * @see evas_object_name_child_find + */ +#define evas_obj_name_child_find(name, recurse, child) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_NAME_CHILD_FIND), EO_TYPECHECK(const char *, name), EO_TYPECHECK(int, recurse), EO_TYPECHECK(Evas_Object **, child) + +/** + * @def evas_obj_key_grab + * + * Requests @p keyname key events be directed to the obj. + * @param[in] keyname in + * @param[in] modifiers in + * @param[in] not_modifiers in + * @param[in] exclusive in + * @param[out] ret out + * + * @see evas_object_key_grab + */ +#define evas_obj_key_grab(keyname, modifiers, not_modifiers, exclusive, ret) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_KEY_GRAB), EO_TYPECHECK(const char *, keyname), EO_TYPECHECK(Evas_Modifier_Mask, modifiers), EO_TYPECHECK(Evas_Modifier_Mask, not_modifiers), EO_TYPECHECK(Eina_Bool, exclusive), EO_TYPECHECK(Eina_Bool *, ret) + +/** + * @def evas_obj_key_ungrab + * + * Removes the grab on @p keyname key events by the obj. + * + * @param[in] keyname + * @param[in] modifiers + * @param[in] not_modifiers + * + * @see evas_object_key_ungrab + */ +#define evas_obj_key_ungrab(keyname, modifiers, not_modifiers) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_KEY_UNGRAB), EO_TYPECHECK(const char *, keyname), EO_TYPECHECK(Evas_Modifier_Mask, modifiers), EO_TYPECHECK(Evas_Modifier_Mask, not_modifiers) + +/** + * @def evas_obj_layer_set + * Sets the layer of the its canvas that the given object will be part + * of. + * + * @param[in] l in + * + * @see evas_object_layer_set() + */ +#define evas_obj_layer_set(l) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_LAYER_SET), EO_TYPECHECK(short, l) + +/** + * @def evas_obj_layer_get + * Retrieves the layer of its canvas that the given object is part of. + * + * @param Number of the its layer + */ +#define evas_obj_layer_get(l) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_LAYER_GET), EO_TYPECHECK(short *, l) + +/** + * @def evas_obj_map_enable_set + * + * Enable or disable the map that is set. + * + * @param[in] enabled in + * + * @see evas_object_map_enable_set + */ +#define evas_obj_map_enable_set(enabled) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_ENABLE_SET), EO_TYPECHECK(Eina_Bool, enabled) + +/** + * @def evas_obj_map_enable_get + * + * Get the map enabled state + * + * @param[out] enabled out + * + * @see evas_object_map_enable_get + */ +#define evas_obj_map_enable_get(enabled) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_ENABLE_GET), EO_TYPECHECK(Eina_Bool *, enabled) + +/** + * @def evas_obj_map_source_set + * + * Set the map source object + * + * @param[in] source in + * + * @see evas_object_map_source_set + */ +#define evas_obj_map_source_set(source) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_SOURCE_SET), EO_TYPECHECK(Evas_Object *, source) + +/** + * @def evas_obj_map_source_get + * + * Get the map source object + * + * @param[out] source out + * + * @see evas_object_map_source_get + */ +#define evas_obj_map_source_get(source) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_SOURCE_GET), EO_TYPECHECK(Evas_Object **, source) + +/** + * @def evas_obj_map_set + * + * Set current object transformation map. + * + * @param[in] map in + * + * @see evas_object_map_set + */ +#define evas_obj_map_set(map) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_SET), EO_TYPECHECK(const Evas_Map *, map) + +/** + * @def evas_obj_map_get + * + * Get current object transformation map. + * + * @param[out] map out + * + * @see evas_object_map_get + */ +#define evas_obj_map_get(map) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_GET), EO_TYPECHECK(const Evas_Map **, map) + +/** + * @def evas_obj_smart_parent_get + * + * Gets the parent smart object of a given Evas object, if it has one. + * + * @param[out] smart_parent out + * + * @see evas_object_smart_parent_get + */ +#define evas_obj_smart_parent_get(smart_parent) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_PARENT_GET), EO_TYPECHECK(Evas_Object **, smart_parent) +/** + * @def evas_obj_smart_data_get + * + * Retrieve user data stored on a given smart object. + * + * @param[out] data out + * + * @see evas_object_smart_data_get + */ +#define evas_obj_smart_data_get(data) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_DATA_GET), EO_TYPECHECK(void **, data) + +/** + * @def evas_obj_smart_type_check + * + * Checks whether a given smart object or any of its smart object + * parents is of a given smart class. + * + * @param[in] type in + * @param[out] type_check out + * + * @see evas_object_smart_type_check + */ +#define evas_obj_smart_type_check(type, type_check) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK), EO_TYPECHECK(const char *, type), EO_TYPECHECK(Eina_Bool *, type_check) + +/** + * @def evas_obj_smart_type_check_ptr + * + * Checks whether a given smart object or any of its smart object + * parents is of a given smart class, using pointer comparison. + * + * @param[in] type in + * @param[out] type_check out + * + * @see evas_object_smart_type_check_ptr + */ +#define evas_obj_smart_type_check_ptr(type, type_check) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK_PTR), EO_TYPECHECK(const char *, type), EO_TYPECHECK(Eina_Bool *, type_check) + +/** + * @def evas_obj_smart_move_children_relative + * + * Moves all children objects of a given smart object relative to a + * given offset. + * + * @param[in] dx in + * @param[in] dy in + * + * @see evas_object_smart_move_children_relative + */ +#define evas_obj_smart_move_children_relative(dx, dy) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_MOVE_CHILDREN_RELATIVE), EO_TYPECHECK(Evas_Coord, dx), EO_TYPECHECK(Evas_Coord, dy) + +/** + * @def evas_obj_smart_clipped_clipper_get + * + * Get the clipper object for the given clipped smart object. + * + * @param[out] ret out + * + * @see evas_object_smart_clipped_clipper_get + */ +#define evas_obj_smart_clipped_clipper_get(ret) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_CLIPPED_CLIPPER_GET), EO_TYPECHECK(Evas_Object **, ret) + +/** + * @def evas_obj_raise + * + * Raise obj to the top of its layer. + * + * @see evas_object_raise + */ +#define evas_obj_raise() EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_RAISE) + +/** + * @def evas_obj_lower + * + * Lower obj to the bottom of its layer. + * + * @see evas_object_lower + */ +#define evas_obj_lower() EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_LOWER) + +/** + * @def evas_obj_stack_above + * + * Stack the object immediately above @p above + * + * @param[in] above in + * + * @see evas_object_stack_above + */ +#define evas_obj_stack_above(above) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STACK_ABOVE), EO_TYPECHECK(Evas_Object *, above) + +/** + * @def evas_obj_stack_below + * + * Stack the object immediately below @p below + * + * @param[in] below in + * + * @see evas_object_stack_below + */ +#define evas_obj_stack_below(below) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STACK_BELOW), EO_TYPECHECK(Evas_Object *, below) + +/** + * @def evas_obj_above_get + * + * Get the Evas object stacked right above the object + * + * @param[out] ret out + * + * @see evas_object_above_get + */ +#define evas_obj_above_get(ret) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_ABOVE_GET), EO_TYPECHECK(Evas_Object **, ret) + +/** + * @def evas_obj_below_get + * + * Get the Evas object stacked right below the object + * + * @param[out] ret out + * + * @see evas_object_below_get + */ +#define evas_obj_below_get(ret) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_BELOW_GET), EO_TYPECHECK(Evas_Object **, ret) + +/** + * @def evas_obj_type_check + * + * Checks whether a given object is of a given class. + * + * @param[in] type in + * @param[out] type_check out + * + * This function has been implemented to support legacy smart inheritance + * and needs to be removed when all the objects are Eo objects (inc. Edje and ELM) + * @see evas_object_smart_type_check + */ +#define evas_obj_type_check(type, type_check) EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_CHECK), EO_TYPECHECK(const char *, type), EO_TYPECHECK(Eina_Bool *, type_check) + +#define EVAS_OBJ_CLASS evas_object_class_get() + +const Eo_Class *evas_object_class_get(void) EINA_CONST; + +#define EVAS_OBJ_IMAGE_CLASS evas_object_image_class_get() +const Eo_Class *evas_object_image_class_get(void) EINA_CONST; + +extern EAPI Eo_Op EVAS_OBJ_IMAGE_BASE_ID; + +enum +{ + EVAS_OBJ_IMAGE_SUB_ID_MEMFILE_SET, + EVAS_OBJ_IMAGE_SUB_ID_FILE_SET, + EVAS_OBJ_IMAGE_SUB_ID_FILE_GET, + EVAS_OBJ_IMAGE_SUB_ID_SOURCE_SET, + EVAS_OBJ_IMAGE_SUB_ID_SOURCE_GET, + EVAS_OBJ_IMAGE_SUB_ID_BORDER_SET, + EVAS_OBJ_IMAGE_SUB_ID_BORDER_GET, + EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_SET, + EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_GET, + EVAS_OBJ_IMAGE_SUB_ID_FILLED_SET, + EVAS_OBJ_IMAGE_SUB_ID_FILLED_GET, + EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_SET, + EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_GET, + EVAS_OBJ_IMAGE_SUB_ID_FILL_SET, + EVAS_OBJ_IMAGE_SUB_ID_FILL_GET, + EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_SET, + EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_GET, + EVAS_OBJ_IMAGE_SUB_ID_SIZE_SET, + EVAS_OBJ_IMAGE_SUB_ID_SIZE_GET, + EVAS_OBJ_IMAGE_SUB_ID_STRIDE_GET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_ERROR_GET, + EVAS_OBJ_IMAGE_SUB_ID_DATA_CONVERT, + EVAS_OBJ_IMAGE_SUB_ID_DATA_SET, + EVAS_OBJ_IMAGE_SUB_ID_DATA_GET, + EVAS_OBJ_IMAGE_SUB_ID_PRELOAD, + EVAS_OBJ_IMAGE_SUB_ID_DATA_COPY_SET, + EVAS_OBJ_IMAGE_SUB_ID_DATA_UPDATE_ADD, + EVAS_OBJ_IMAGE_SUB_ID_ALPHA_SET, + EVAS_OBJ_IMAGE_SUB_ID_ALPHA_GET, + EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_SET, + EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_GET, + EVAS_OBJ_IMAGE_SUB_ID_RELOAD, + EVAS_OBJ_IMAGE_SUB_ID_SAVE, + EVAS_OBJ_IMAGE_SUB_ID_PIXELS_IMPORT, + EVAS_OBJ_IMAGE_SUB_ID_PIXELS_GET_CALLBACK_SET, + EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_SET, + EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_GET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_SET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_GET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_SET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_GET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_SET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_GET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_SET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_GET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_SET, + EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_GET, + EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_SET, + EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_GET, + EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_SET, + EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_GET, + EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_SET, + EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_GET, + EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_SET, + EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_GET, + EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_SET, + EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_GET, + EVAS_OBJ_IMAGE_SUB_ID_REGION_SUPPORT_GET, + EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_GET, + EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_COUNT_GET, + EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_TYPE_GET, + EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_COUNT_GET, + EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_DURATION_GET, + EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET, + EVAS_OBJ_IMAGE_SUB_ID_LAST +}; + +#define EVAS_OBJ_IMAGE_ID(sub_id) (EVAS_OBJ_IMAGE_BASE_ID + sub_id) + +/** + * @def evas_obj_image_memfile_set + * + * Sets the data for an image from memory to be loaded + * + * @param[in] data in + * @param[in] size in + * @param[in] format in + * @param[in] key in + * + * @see evas_object_image_memfile_set + */ +#define evas_obj_image_memfile_set(data, size, format, key) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_MEMFILE_SET), EO_TYPECHECK(void *, data), EO_TYPECHECK(int, size), EO_TYPECHECK(char *, format), EO_TYPECHECK(char *, key) + +/** + * @def evas_obj_image_file_set + * + * Set the source file from where an image object must fetch the real + * image data (it may be an Eet file, besides pure image ones). + * + * @param[in] file in + * @param[in] key in + * + * @see evas_object_image_file_set + */ +#define evas_obj_image_file_set(file, key) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILE_SET), EO_TYPECHECK(const char *, file), EO_TYPECHECK(const char*, key) + +/** + * @def evas_obj_image_file_get + * + * This is the same as evas_object_image_file_set() but the file to be loaded + * may exist at an address in memory (the data for the file, not the filename + * itself). The @p data at the address is copied and stored for future use, so + * no @p data needs to be kept after this call is made. It will be managed and + * freed for you when no longer needed. The @p size is limited to 2 gigabytes + * in size, and must be greater than 0. A @c NULL @p data pointer is also + * invalid. Set the filename to @c NULL to reset to empty state and have the + * image file data freed from memory using evas_object_image_file_set(). + * + * @param[in] file out + * @param[in] key out + * + * @see evas_object_image_file_get + */ +#define evas_obj_image_file_get(file, key) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILE_GET), EO_TYPECHECK(const char **, file), EO_TYPECHECK(const char **, key) + +/** + * @def evas_obj_image_source_set + * + * Set the source object on an image object to used as a @b proxy. + * + * @param[in] src in + * @param[out] result out + * + * @see evas_object_image_source_set + */ +#define evas_obj_image_source_set(src, result) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_SET), EO_TYPECHECK(Evas_Object *, src), EO_TYPECHECK(Eina_Bool *, result) + +/** + * @def evas_obj_image_source_get + * + * Get the current source object of an image object. + * + * @param[out] src out + * + * @see evas_object_image_source_get + */ +#define evas_obj_image_source_get(src) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_GET), EO_TYPECHECK(Evas_Object **, src) + +/** + * @def evas_obj_image_border_set + * + * Set the dimensions for an image object's border, a region which @b + * won't ever be scaled together with its center. + * + * @param[in] l in + * @param[in] r in + * @param[in] t in + * @param[in] b in + * + * @see evas_object_image_border_set + */ +#define evas_obj_image_border_set(l, r, t, b) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SET), EO_TYPECHECK(int, l), EO_TYPECHECK(int, r), EO_TYPECHECK(int, t), EO_TYPECHECK(int, b) + +/** + * @def evas_obj_image_border_get + * + * Retrieve the dimensions for an image object's border, a region + * which @b won't ever be scaled together with its center. + * + * @param[out] l in + * @param[out] r in + * @param[out] t in + * @param[out] b in + * + * @see evas_object_image_border_get + */ +#define evas_obj_image_border_get(l, r, t, b) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_GET), EO_TYPECHECK(int *, l), EO_TYPECHECK(int *, r), EO_TYPECHECK(int *, t), EO_TYPECHECK(int *, b) + +/** + * @def evas_obj_image_border_center_fill_set + * + * Sets @b how the center part of the given image object (not the + * borders) should be drawn when Evas is rendering it. + * + * @param[in] fill in + * + * @see evas_object_image_border_center_fill_set + */ +#define evas_obj_image_border_center_fill_set(fill) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_SET), EO_TYPECHECK(Evas_Border_Fill_Mode, fill) + +/** + * @def evas_obj_image_border_center_fill_get + * + * Retrieves @b how the center part of the given image object (not the + * borders) is to be drawn when Evas is rendering it. + * + * @param[out] fill out + * + * @see evas_object_image_border_center_fill_get + */ +#define evas_obj_image_border_center_fill_get(fill) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_GET), EO_TYPECHECK(Evas_Border_Fill_Mode *, fill) + +/** + * @def evas_obj_image_filled_set + * + * Set whether the image object's fill property should track the + * object's size. + * + * @param[in] filled in + * + * @see evas_object_image_filled_set + */ +#define evas_obj_image_filled_set(filled) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILLED_SET), EO_TYPECHECK(Eina_Bool, filled) + +/** + * @def evas_obj_image_filled_get + * + * Retrieve whether the image object's fill property should track the + * object's size. + * + * @param[out] filled out + * + * @see evas_object_image_filled_get + */ +#define evas_obj_image_filled_get(filled) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILLED_GET), EO_TYPECHECK(Eina_Bool *, filled) + +/** + * @def evas_obj_image_border_scale_set + * + * Sets the scaling factor (multiplier) for the borders of an image + * object. + * + * @param[in] scale in + * + * @see evas_object_image_border_scale_set + */ +#define evas_obj_image_border_scale_set(scale) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_SET), EO_TYPECHECK(double, scale) + +/** + * @def evas_obj_image_border_scale_get + * + * Retrieves the scaling factor (multiplier) for the borders of an + * image object. + * + * @param[out] scale out + * + * @see evas_object_image_border_scale_get + */ +#define evas_obj_image_border_scale_get(scale) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_GET), EO_TYPECHECK(double *, scale) + +/** + * @def evas_obj_image_fill_set + * + * Set how to fill an image object's drawing rectangle given the + * (real) image bound to it. + * + * @param[in] x in + * @param[in] y in + * @param[in] w in + * @param[in] h in + * + * @see evas_object_image_fill_set + */ +#define evas_obj_image_fill_set(x, y, w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SET), EO_TYPECHECK(Evas_Coord, x), EO_TYPECHECK(Evas_Coord, y), EO_TYPECHECK(Evas_Coord, w), EO_TYPECHECK(Evas_Coord, h) + +/** + * @def evas_obj_image_fill_get + * + * Retrieve how an image object is to fill its drawing rectangle, + * given the (real) image bound to it. + * + * @param[out] x out + * @param[out] y out + * @param[out] w out + * @param[out] h out + * + * @see evas_object_image_fill_get + */ +#define evas_obj_image_fill_get(x, y, w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_GET), EO_TYPECHECK(Evas_Coord *, x), EO_TYPECHECK(Evas_Coord *, y), EO_TYPECHECK(Evas_Coord *, w), EO_TYPECHECK(Evas_Coord *, h) + +/** + * @def evas_obj_image_fill_spread_set + * + * Sets the tiling mode for the given evas image object's fill. + * + * @param[in] spread in + * + * @see evas_object_image_fill_spread_set + */ +#define evas_obj_image_fill_spread_set(spread) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_SET), EO_TYPECHECK(Evas_Fill_Spread, spread) + +/** + * @def evas_obj_image_fill_spread_get + * + * Retrieves the spread (tiling mode) for the given image object's + * fill. + * + * @param[out] spread out + * + * @see evas_object_image_fill_spread_get + */ +#define evas_obj_image_fill_spread_get(spread) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_GET), EO_TYPECHECK(Evas_Fill_Spread *, spread) + +/** + * @def evas_obj_image_size_set + * + * Sets the size of the given image object. + * + * @param[in] w in + * @param[in] h in + * + * @see evas_object_image_size_set + */ +#define evas_obj_image_size_set(w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SIZE_SET), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) + +/** + * @def evas_obj_image_size_get + * + * Retrieves the size of the given image object. + * + * @param[out] w out + * @param[out] h out + * + * @see evas_object_image_size_get + */ +#define evas_obj_image_size_get(w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SIZE_GET), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h) + +/** + * @def evas_obj_image_stride_get + * + * Retrieves the row stride of the given image object. + * + * @param[out] stride out + * + * @see evas_object_image_stride_get + */ +#define evas_obj_image_stride_get(stride) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_STRIDE_GET), EO_TYPECHECK(int *, stride) + +/** + * @de evas_obj_image_load_error_get + * + * Retrieves a number representing any error that occurred during the + * last loading of the given image object's source image. + * + * @param[out] load_error out + * + * @see evas_object_image_load_error_get + */ +#define evas_obj_image_load_error_get(load_error) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ERROR_GET), EO_TYPECHECK(Evas_Load_Error *, load_error) + +/** + * @def evas_obj_image_data_convert + * + * Converts the raw image data of the given image object to the + * specified colorspace. + * + * @param[in] cspace in + * @param[out] data out + * + * @see evas_object_image_data_convert + */ +#define evas_obj_image_data_convert(to_cspace, data) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_CONVERT), EO_TYPECHECK(Evas_Colorspace, to_cspace), EO_TYPECHECK(void **, data) + +/** + * @def evas_obj_image_data_set + * + * Sets the raw image data of the given image object. + * + * @param[in] data in + * + * @see evas_object_image_data_set + */ +#define evas_obj_image_data_set(data) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_SET), EO_TYPECHECK(void *, data) + +/** + * @def evas_obj_image_data_get + * + * Get a pointer to the raw image data of the given image object. + * + * @param[in] for_writing in + * @param[out] data out + * + * @see evas_object_image_data_get + */ +#define evas_obj_image_data_get(for_writing, data) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_GET), EO_TYPECHECK(Eina_Bool, for_writing), EO_TYPECHECK(void **, data) + +/** + * @def evas_obj_image_data_copy_set + * + * Replaces the raw image data of the given image object. + * + * @param[in] data in + * + * @see evas_object_image_data_copy_set + */ +#define evas_obj_image_data_copy_set(data) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_COPY_SET), EO_TYPECHECK(void *, data) + +/** + * @def evas_obj_image_data_update_add + * + * Mark a sub-region of the given image object to be redrawn. + * + * @param[in] x in + * @param[in] y in + * @param[in] r in + * @param[in] h in + * + * @see evas_object_image_data_update_add + */ +#define evas_obj_image_data_update_add(x, y, w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_UPDATE_ADD), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) + +/** + * @def evas_obj_image_alpha_set + * + * Enable or disable alpha channel usage on the given image object. + * + * @param[in] alpha in + * + * @see evas_object_image_alpha_set + */ +#define evas_obj_image_alpha_set(alpha) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_SET), EO_TYPECHECK(Eina_Bool, alpha) + +/** + * @def evas_obj_image_alpha_get + * + * Retrieve whether alpha channel data is being used on the given + * image object. + * + * @param[out] alpha out + * + * @see evas_object_image_alpha_get + */ +#define evas_obj_image_alpha_get(alpha) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_GET), EO_TYPECHECK(Eina_Bool *, alpha) + +/** + * @def evas_obj_image_smooth_scale_set + * + * Sets whether to use high-quality image scaling algorithm on the + * given image object. + * + * @param[in] smooth_scale in + * + * @see evas_object_image_smooth_scale_set + */ +#define evas_obj_image_smooth_scale_set(smooth_scale) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_SET), EO_TYPECHECK(Eina_Bool, smooth_scale) + +/** + * @def evas_obj_image_smooth_scale_get + * + * Retrieves whether the given image object is using high-quality + * image scaling algorithm. + * + * @param[out] smooth_scale out + * + * @see evas_object_image_smooth_scale_get + */ +#define evas_obj_image_smooth_scale_get(smooth_scale) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_GET), EO_TYPECHECK(Eina_Bool *, smooth_scale) + +/** + * @def evas_obj_image_preload + * + * Preload an image object's image data in the background + * + * @param[in] cancel in + * + * @see evas_object_image_preload + */ +#define evas_obj_image_preload(cancel) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD), EO_TYPECHECK(Eina_Bool, cancel) + +/** + * @def evas_obj_image_reload + * + * Reload an image object's image data. + * + * @see evas_object_image_reload + */ +#define evas_obj_image_reload() EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_RELOAD) + +/** + * @def evas_obj_image_save + * + * Save the given image object's contents to an (image) file. + * + * @param[in] file in + * @param[in] key in + * @param[in] flags in + * @param[out] result out + * + * @see evas_object_image_save + */ +#define evas_obj_image_save(file, key, flags, result) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SAVE), EO_TYPECHECK(const char *, file), EO_TYPECHECK(const char *, key), EO_TYPECHECK(const char *, flags), EO_TYPECHECK(Eina_Bool *, result) + +/** + * @def evas_obj_image_pixels_import + * + * Import pixels from given source to a given canvas image object. + * + * @param[in] pixels in + * @param[out] result out + * + * @see evas_object_image_pixels_import + */ +#define evas_obj_image_pixels_import(pixels, result) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_IMPORT), EO_TYPECHECK(Evas_Pixel_Import_Source *, pixels), EO_TYPECHECK(Eina_Bool *, result) + +/** + * @def evas_obj_image_pixels_get_callback_set + * + * Set the callback function to get pixels from a canvas' image. + * + * @param[in] func in + * @param[in] data in + * + * @see evas_object_image_pixels_get_callback_set + */ +#define evas_obj_image_pixels_get_callback_set(func, data) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_GET_CALLBACK_SET), EO_TYPECHECK(Evas_Object_Image_Pixels_Get_Cb, func), EO_TYPECHECK(void *, data) + +/** + * @def evas_obj_image_pixels_dirty_set + * + * Mark whether the given image object is dirty (needs to be redrawn). + * + * @param[in] dirty in + * + * @see evas_object_image_pixels_get_callback_set + */ +#define evas_obj_image_pixels_dirty_set(dirty) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_SET), EO_TYPECHECK(Eina_Bool, dirty) + +/** + * @def evas_obj_image_pixels_dirty_get + * + * Retrieves whether the given image object is dirty (needs to be redrawn). + * + * @param[out] dirty out + * + * @see evas_object_image_pixels_dirty_get + */ +#define evas_obj_image_pixels_dirty_get(dirty) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_GET), EO_TYPECHECK(Eina_Bool *, dirty) + +/** + * @def evas_obj_image_load_dpi_set + * + * Set the DPI resolution of an image object's source image. + * + * @param[in] dpi in + * + * @see evas_object_image_load_dpi_set + */ +#define evas_obj_image_load_dpi_set(dpi) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_SET), EO_TYPECHECK(double, dpi) + +/** + * @def evas_obj_image_load_dpi_get + * + * Get the DPI resolution of a loaded image object in the canvas. + * + * @param[out] dpi out + * + * @see evas_object_image_load_dpi_get + */ +#define evas_obj_image_load_dpi_get(dpi) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_GET), EO_TYPECHECK(double *, dpi) + +/** + * @def evas_obj_image_load_size_set + * + * Set the size of a given image object's source image, when loading + * it. + * + * @param[in] w in + * @param[in] h in + * + * @see evas_object_image_load_size_set + */ +#define evas_obj_image_load_size_set(w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_SET), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) + +/** + * @def evas_obj_image_load_size_get + * + * Get the size of a given image object's source image, when loading + * it. + * + * @param[out] w out + * @param[out] h out + * + * @see evas_object_image_load_size_get + */ +#define evas_obj_image_load_size_get(w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_GET), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h) + +/** + * @def evas_obj_image_load_scale_down_set + * + * Set the scale down factor of a given image object's source image, + * when loading it. + * + * @param[in] scale_down in + * + * @see evas_object_image_load_scale_down_set + */ +#define evas_obj_image_load_scale_down_set(scale_down) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_SET), EO_TYPECHECK(int, scale_down) + +/** + * @def evas_obj_image_load_scale_down_get + * + * Get the scale down factor of a given image object's source image, + * when loading it. + * + * @param[out] scale_down out + * + * @see evas_object_image_load_scale_down_get + */ +#define evas_obj_image_load_scale_down_get(scale_down) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_GET), EO_TYPECHECK(int *, scale_down) + +/** + * @def evas_obj_image_load_region_set + * + * Inform a given image object to load a selective region of its + * source image. + * + * @param[in] x in + * @param[in] y in + * @param[in] w in + * @param[in] h in + * + * @see evas_object_image_load_region_set + */ +#define evas_obj_image_load_region_set(x, y, w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_SET), EO_TYPECHECK(int, x), EO_TYPECHECK(int, y), EO_TYPECHECK(int, w), EO_TYPECHECK(int, h) + +/** + * Retrieve the coordinates of a given image object's selective + * (source image) load region. + * + * @param[out] x out + * @param[out] y out + * @param[out] w out + * @param[out] h out + * + * @see evas_object_image_load_region_get + */ +#define evas_obj_image_load_region_get(x, y, w, h) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_GET), EO_TYPECHECK(int *, x), EO_TYPECHECK(int *, y), EO_TYPECHECK(int *, w), EO_TYPECHECK(int *, h) + +/** + * @def evas_obj_image_load_orientation_set + * + * Define if the orientation information in the image file should be honored. + * + * @param[in] enable in + * + * @see evas_object_image_load_orientation_set + */ +#define evas_obj_image_load_orientation_set(enable) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_SET), EO_TYPECHECK(Eina_Bool, enable) + +/** + * @def evas_obj_image_load_orientation_get + * + * Get if the orientation information in the image file should be honored. + * + * @param[out] enable out + * + * @see evas_object_image_load_orientation_get + */ +#define evas_obj_image_load_orientation_get(enable) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_GET), EO_TYPECHECK(Eina_Bool *, enable) + +/** + * @def evas_obj_image_colorspace_set + * + * Set the colorspace of a given image of the canvas. + * + * @param[in] cspace in + * + * @see evas_object_image_colorspace_set + */ +#define evas_obj_image_colorspace_set(cspace) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_SET), EO_TYPECHECK(Evas_Colorspace, cspace) + +/** + * @def evas_obj_image_colorspace_get + * + * Get the colorspace of a given image of the canvas. + * + * @param[out] cspace out + * + * @see evas_object_image_colorspace_get + */ +#define evas_obj_image_colorspace_get(cspace) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_GET), EO_TYPECHECK(Evas_Colorspace *, cspace) + +/** + * @def evas_obj_image_video_surface_set + * + * Set the video surface linked to a given image of the canvas + * + * @param[in] surf in + * + * @see evas_object_image_video_surface_set + */ +#define evas_obj_image_video_surface_set(surf) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_SET), EO_TYPECHECK(Evas_Video_Surface *, surf) + +/** + * @def evas_obj_image_video_surface_get + * + * Get the video surface linked to a given image of the canvas + * + * @param[out] surf out + * + * @see evas_object_image_video_surface_get + */ +#define evas_obj_image_video_surface_get(surf) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_GET), EO_TYPECHECK(const Evas_Video_Surface **, surf) + +/** + * @def evas_obj_image_native_surface_set + * + * Set the native surface of a given image of the canvas + * + * @param[in] surf in + * + * @see evas_object_image_native_surface_set + */ +#define evas_obj_image_native_surface_set(surf) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_SET), EO_TYPECHECK(Evas_Native_Surface *, surf) + +/** + * @def evas_obj_image_native_surface_get + * + * Get the native surface of a given image of the canvas + * + * @param[out] surf out + * + * @see evas_object_image_native_surface_get + */ +#define evas_obj_image_native_surface_get(surf) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_GET), EO_TYPECHECK(Evas_Native_Surface **, surf) + +/** + * @def evas_obj_image_scale_hint_set + * + * Set the scale hint of a given image of the canvas. + * + * @param[in] hint in + * + * @see evas_object_image_scale_hint_set + */ +#define evas_obj_image_scale_hint_set(hint) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_SET), EO_TYPECHECK(Evas_Image_Scale_Hint, hint) + +/** + * @def evas_obj_image_scale_hint_get + * + * Get the scale hint of a given image of the canvas. + * + * @param[out] hint out + * + * @see evas_object_image_scale_hint_get + */ +#define evas_obj_image_scale_hint_get(hint) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_GET), EO_TYPECHECK(Evas_Image_Scale_Hint *, hint) + +/** + * @def evas_obj_image_content_hint_set + * + * Set the content hint setting of a given image object of the canvas. + * + * @param[in] hint in + * + * @see evas_object_image_content_hint_set + */ +#define evas_obj_image_content_hint_set(hint) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_SET), EO_TYPECHECK(Evas_Image_Content_Hint, hint) + +/** + * @def evas_obj_image_content_hint_get + * + * Get the content hint setting of a given image object of the canvas. + * + * @param[out] hint out + * + * @see evas_object_image_content_hint_get + */ +#define evas_obj_image_content_hint_get(hint) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_GET), EO_TYPECHECK(Evas_Image_Content_Hint *, hint) + +/** + * @def evas_obj_image_region_support_get + * + * Get the support state of a given image + * + * @param[out] region out + * + * @see evas_object_image_region_support_get + */ +#define evas_obj_image_region_support_get(region) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_REGION_SUPPORT_GET), EO_TYPECHECK(Eina_Bool *, region) + +/** + * @def evas_obj_image_animated_get + * + * Check if an image object can be animated (have multiple frames) + * + * @param[out] animated out + * + * @see evas_object_image_animated_get + */ +#define evas_obj_image_animated_get(animated) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_GET), EO_TYPECHECK(Eina_Bool *, animated) + +/** + * @def evas_obj_image_animated_frame_count_get + * + * Get the total number of frames of the image object. + * + * @param[out] frame_count out + * + * @see evas_object_image_animated_frame_count_get + */ +#define evas_obj_image_animated_frame_count_get(frame_count) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_COUNT_GET), EO_TYPECHECK(int *, frame_count) + +/** + * @def evas_obj_image_animated_loop_type_get + * + * Get the kind of looping the image object does. + * + * @param[out] hint out + * + * @see evas_object_image_animated_loop_type_get + */ +#define evas_obj_image_animated_loop_type_get(hint) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_TYPE_GET), EO_TYPECHECK(Evas_Image_Animated_Loop_Hint *, hint) + +/** + * @def evas_obj_image_animated_loop_count_get + * + * Get the number times the animation of the object loops. + * + * @param[out] loop_count out + * + * @see evas_object_image_animated_loop_count_get + */ +#define evas_obj_image_animated_loop_count_get(loop_count) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_COUNT_GET), EO_TYPECHECK(int *, loop_count) + +/** + * @def evas_obj_image_animated_frame_duration_get + * + * Get the duration of a sequence of frames. + * + * @param[in] start_frame in + * @param[in] frame_num in + * @param[out] frame_duration out + * + * @see evas_object_image_animated_frame_duration_get + */ +#define evas_obj_image_animated_frame_duration_get(start_frame, frame_num, frame_duration) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_DURATION_GET), EO_TYPECHECK(int, start_frame), EO_TYPECHECK(int, frame_num), EO_TYPECHECK(double *, frame_duration) + +/** + * @def evas_obj_image_animated_frame_set + * + * Set the frame to current frame of an image object + * + * @param[in] frame_index in + * + * @see evas_object_image_animated_frame_set + */ +#define evas_obj_image_animated_frame_set(frame_index) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET), EO_TYPECHECK(int, frame_index) + #ifdef __cplusplus } #endif diff --git a/legacy/evas/src/lib/Makefile.am b/legacy/evas/src/lib/Makefile.am index c6ceafb53c..fe44f3dcb0 100644 --- a/legacy/evas/src/lib/Makefile.am +++ b/legacy/evas/src/lib/Makefile.am @@ -171,6 +171,7 @@ AM_CPPFLAGS = \ @EET_CFLAGS@ \ @FONTCONFIG_CFLAGS@ \ @pthread_cflags@ \ +@EO_CFLAGS@ \ @PIXMAN_CFLAGS@ lib_LTLIBRARIES = libevas.la @@ -209,6 +210,7 @@ engines/common/libevas_engine_common.la \ $(EVAS_STATIC_MODULE) \ $(EVAS_STATIC_LIBADD) \ @PIXMAN_LIBS@ \ +@EO_LIBS@ \ -lm libevas_la_DEPENDENCIES = \ diff --git a/legacy/evas/src/lib/canvas/Makefile.am b/legacy/evas/src/lib/canvas/Makefile.am index 2ed5c50ae4..b5c27408b8 100644 --- a/legacy/evas/src/lib/canvas/Makefile.am +++ b/legacy/evas/src/lib/canvas/Makefile.am @@ -20,8 +20,10 @@ AM_CPPFLAGS = \ noinst_LTLIBRARIES = libevas_canvas.la libevas_canvas_la_SOURCES = \ +common_interfaces.c \ evas_callbacks.c \ evas_clip.c \ +evas_common_interface.c \ evas_data.c \ evas_device.c \ evas_events.c \ diff --git a/legacy/evas/src/lib/canvas/common_interfaces.c b/legacy/evas/src/lib/canvas/common_interfaces.c new file mode 100644 index 0000000000..0246138f34 --- /dev/null +++ b/legacy/evas/src/lib/canvas/common_interfaces.c @@ -0,0 +1,271 @@ +#include "evas_common.h" +#include "evas_private.h" + +#include "Eo.h" + +Eina_Hash* signals_hash_table = NULL; + +EAPI const Eo_Event_Description _CLICKED_EVENT = + EO_EVENT_DESCRIPTION("clicked", ""); + +EAPI const Eo_Event_Description _CLICKED_DOUBLE_EVENT = + EO_EVENT_DESCRIPTION("clicked,double", ""); + +EAPI const Eo_Event_Description _CLICKED_TRIPLE_EVENT = + EO_EVENT_DESCRIPTION("clicked,triple", ""); + +EAPI const Eo_Event_Description _PRESSED_EVENT = + EO_EVENT_DESCRIPTION("pressed", ""); + +EAPI const Eo_Event_Description _UNPRESSED_EVENT = + EO_EVENT_DESCRIPTION("unpressed", ""); + +EAPI const Eo_Event_Description _LONGPRESSED_EVENT = + EO_EVENT_DESCRIPTION("longpressed", ""); + +EAPI const Eo_Event_Description _REPEATED_EVENT = + EO_EVENT_DESCRIPTION("repeated", ""); + +EAPI const Eo_Event_Description _SCROLL_EVENT = + EO_EVENT_DESCRIPTION("scroll", ""); + +EAPI const Eo_Event_Description _SCROLL_ANIM_START_EVENT = + EO_EVENT_DESCRIPTION("scroll,anim,start", ""); + +EAPI const Eo_Event_Description _SCROLL_ANIM_STOP_EVENT = + EO_EVENT_DESCRIPTION("scroll,anim,stop", ""); + +EAPI const Eo_Event_Description _SCROLL_DRAG_START_EVENT = + EO_EVENT_DESCRIPTION("scroll,drag,start", ""); + +EAPI const Eo_Event_Description _SCROLL_DRAG_STOP_EVENT = + EO_EVENT_DESCRIPTION("scroll,drag,stop", ""); + +EAPI const Eo_Event_Description _ZOOM_START_EVENT = + EO_EVENT_DESCRIPTION("zoom,start", ""); + +EAPI const Eo_Event_Description _ZOOM_STOP_EVENT = + EO_EVENT_DESCRIPTION("zoom,stop", ""); + +EAPI const Eo_Event_Description _ZOOM_CHANGE_EVENT = + EO_EVENT_DESCRIPTION("zoom,changed", ""); + +EAPI const Eo_Event_Description _SELECTED_EVENT = + EO_EVENT_DESCRIPTION("selected", ""); + +EAPI const Eo_Event_Description _UNSELECTED_EVENT = + EO_EVENT_DESCRIPTION("unselected", ""); + +EAPI const Eo_Event_Description _SELECTION_PASTE_EVENT = + EO_EVENT_DESCRIPTION("selection,paste", ""); + +EAPI const Eo_Event_Description _SELECTION_COPY_EVENT = + EO_EVENT_DESCRIPTION("selection,copy", ""); + +EAPI const Eo_Event_Description _SELECTION_CUT_EVENT = + EO_EVENT_DESCRIPTION("selection,cut", ""); + +EAPI const Eo_Event_Description _SELECTION_START_EVENT = + EO_EVENT_DESCRIPTION("selection,start", ""); + +EAPI const Eo_Event_Description _SELECTION_CHANGED_EVENT = + EO_EVENT_DESCRIPTION("selection,changed", ""); + +EAPI const Eo_Event_Description _SELECTION_CLEARED_EVENT = + EO_EVENT_DESCRIPTION("selection,cleared", ""); + +EAPI const Eo_Event_Description _DRAG_EVENT = + EO_EVENT_DESCRIPTION("drag", ""); + +EAPI const Eo_Event_Description _DRAG_START_EVENT = + EO_EVENT_DESCRIPTION("drag,start", ""); + +EAPI const Eo_Event_Description _DRAG_STOP_EVENT = + EO_EVENT_DESCRIPTION("drag,stop", ""); + +EAPI const Eo_Event_Description _DRAG_END_EVENT = + EO_EVENT_DESCRIPTION("drag,end", ""); + +EAPI const Eo_Event_Description _DRAG_START_UP_EVENT = + EO_EVENT_DESCRIPTION("drag,start,up", ""); + +EAPI const Eo_Event_Description _DRAG_START_DOWN_EVENT = + EO_EVENT_DESCRIPTION("drag,start,down", ""); + +EAPI const Eo_Event_Description _DRAG_START_RIGHT_EVENT = + EO_EVENT_DESCRIPTION("drag,start,right", ""); + +EAPI const Eo_Event_Description _DRAG_START_LEFT_EVENT = + EO_EVENT_DESCRIPTION("drag,start,left", ""); + +static const Eo_Event_Description *_clickable_events_desc[] = { + EVAS_SMART_CLICKED_EVENT, + EVAS_SMART_CLICKED_DOUBLE_EVENT, + EVAS_SMART_CLICKED_TRIPLE_EVENT, + EVAS_SMART_PRESSED_EVENT, + EVAS_SMART_UNPRESSED_EVENT, + EVAS_SMART_LONGPRESSED_EVENT, + EVAS_SMART_REPEATED_EVENT, + NULL +}; + +static const Eo_Event_Description *_scrollable_events_desc[] = { + EVAS_SMART_SCROLL_EVENT, + EVAS_SMART_SCROLL_ANIM_START_EVENT, + EVAS_SMART_SCROLL_ANIM_STOP_EVENT, + EVAS_SMART_SCROLL_DRAG_START_EVENT, + EVAS_SMART_SCROLL_DRAG_STOP_EVENT, + NULL +}; + +static const Eo_Event_Description *_zoomable_events_desc[] = { + EVAS_SMART_ZOOM_START_EVENT, + EVAS_SMART_ZOOM_STOP_EVENT, + EVAS_SMART_ZOOM_CHANGE_EVENT, + NULL +}; + +static const Eo_Event_Description *_selectable_events_desc[] = { + EVAS_SMART_SELECTED_EVENT, + EVAS_SMART_UNSELECTED_EVENT, + EVAS_SMART_SELECTION_PASTE_EVENT, + EVAS_SMART_SELECTION_COPY_EVENT, + EVAS_SMART_SELECTION_CUT_EVENT, + EVAS_SMART_SELECTION_START_EVENT, + EVAS_SMART_SELECTION_CHANGED_EVENT, + EVAS_SMART_SELECTION_CLEARED_EVENT, + NULL +}; + +static const Eo_Event_Description *_draggable_events_desc[] = { + EVAS_SMART_DRAG_EVENT, + EVAS_SMART_DRAG_START_EVENT, + EVAS_SMART_DRAG_STOP_EVENT, + EVAS_SMART_DRAG_END_EVENT, + EVAS_SMART_DRAG_START_UP_EVENT, + EVAS_SMART_DRAG_START_DOWN_EVENT, + EVAS_SMART_DRAG_START_RIGHT_EVENT, + EVAS_SMART_DRAG_START_LEFT_EVENT, + NULL +}; + +#define ADD_SIGNAL(name, event) eina_hash_add(signals_hash_table, name, event) +#define ADD_INTERFACE_SIGNALS(events_desc) \ + do \ + { \ + int i = 0; \ + while (events_desc[i]) { \ + _Evas_Event_Description *desc = calloc(1, sizeof(*desc)); \ + desc->eo_desc = (Eo_Event_Description *)events_desc[i]; \ + desc->is_desc_allocated = EINA_FALSE; \ + ADD_SIGNAL(events_desc[i]->name, desc); \ + i++; \ + } \ + } \ + while (0); + +static void +_signal_interface_del(void *data) +{ + _Evas_Event_Description *desc = data; + if (desc->is_desc_allocated) free(desc->eo_desc); + free(desc); +} + +static void +_signal_interface_constructor(Eo_Class *klass EINA_UNUSED) +{ + signals_hash_table = eina_hash_string_superfast_new(_signal_interface_del); + ADD_INTERFACE_SIGNALS(_clickable_events_desc); + ADD_INTERFACE_SIGNALS(_scrollable_events_desc); + ADD_INTERFACE_SIGNALS(_zoomable_events_desc); + ADD_INTERFACE_SIGNALS(_selectable_events_desc); + ADD_INTERFACE_SIGNALS(_draggable_events_desc); +} +#undef ADD_INTERFACE_SIGNALS +#undef ADD_SIGNAL + +static void +_signal_interface_destructor(Eo_Class *klass EINA_UNUSED) +{ + eina_hash_free(signals_hash_table); +} + +static const Eo_Class_Description signal_interface_desc = { + EO_VERSION, + "Signal_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + NULL, + 0, + _signal_interface_constructor, + _signal_interface_destructor +}; + +EO_DEFINE_CLASS(evas_smart_signal_interface_get, &signal_interface_desc, NULL, NULL); + +static const Eo_Class_Description clickable_interface_desc = { + EO_VERSION, + "Clickable_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + _clickable_events_desc, + 0, + NULL, + NULL +}; + +EO_DEFINE_CLASS(evas_smart_clickable_interface_get, &clickable_interface_desc, EVAS_SMART_SIGNAL_INTERFACE, NULL); + +static const Eo_Class_Description scrollable_interface_desc = { + EO_VERSION, + "Scrollable_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + _scrollable_events_desc, + 0, + NULL, + NULL +}; + +EO_DEFINE_CLASS(evas_smart_scrollable_interface_get, &scrollable_interface_desc, EVAS_SMART_SIGNAL_INTERFACE, NULL); + +static const Eo_Class_Description zoomable_interface_desc = { + EO_VERSION, + "Zoomable_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + _zoomable_events_desc, + 0, + NULL, + NULL +}; + +EO_DEFINE_CLASS(evas_smart_zoomable_interface_get, &zoomable_interface_desc, EVAS_SMART_SIGNAL_INTERFACE, NULL); + +static const Eo_Class_Description selectable_interface_desc = { + EO_VERSION, + "Selectable_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + _selectable_events_desc, + 0, + NULL, + NULL +}; + +EO_DEFINE_CLASS(evas_smart_selectable_interface_get, &selectable_interface_desc, EVAS_SMART_SIGNAL_INTERFACE, NULL); + +static const Eo_Class_Description draggable_interface_desc = { + EO_VERSION, + "Draggable_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + _draggable_events_desc, + 0, + NULL, + NULL +}; + +EO_DEFINE_CLASS(evas_smart_draggable_interface_get, &draggable_interface_desc, EVAS_SMART_SIGNAL_INTERFACE, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_callbacks.c b/legacy/evas/src/lib/canvas/evas_callbacks.c index dfd8099f94..faf84455e6 100644 --- a/legacy/evas/src/lib/canvas/evas_callbacks.c +++ b/legacy/evas/src/lib/canvas/evas_callbacks.c @@ -1,16 +1,125 @@ #include "evas_common.h" #include "evas_private.h" -static void evas_object_event_callback_clear(Evas_Object *obj); -static void evas_event_callback_clear(Evas *e); +static void evas_object_event_callback_clear(Evas_Object *eo_obj); +static void evas_event_callback_clear(Evas *eo_e); int _evas_event_counter = 0; EVAS_MEMPOOL(_mp_fn); EVAS_MEMPOOL(_mp_cb); EVAS_MEMPOOL(_mp_pc); +extern Eina_Hash* signals_hash_table; + +EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_IN = + EO_EVENT_DESCRIPTION("Mouse In", "Mouse In Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_OUT = + EO_EVENT_DESCRIPTION("Mouse Out", "Mouse Out Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_DOWN = + EO_EVENT_DESCRIPTION("Mouse Down", "Mouse Button Down Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_UP = + EO_EVENT_DESCRIPTION("Mouse Up", "Mouse Button Up Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_MOVE = + EO_EVENT_DESCRIPTION("Mouse Move", "Mouse Move Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_WHEEL = + EO_EVENT_DESCRIPTION("Mouse Wheel", "Mouse Wheel Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MULTI_DOWN = + EO_EVENT_DESCRIPTION("Multi Down", "Mouse-touch Down Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MULTI_UP = + EO_EVENT_DESCRIPTION("Multi Up", "Mouse-touch Up Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MULTI_MOVE = + EO_EVENT_DESCRIPTION("Multi Move", "Multi-touch Move Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_FREE = + EO_EVENT_DESCRIPTION("Free", "Object Being Freed (Called after Del)"); +EAPI const Eo_Event_Description _EVAS_EVENT_KEY_DOWN = + EO_EVENT_DESCRIPTION("Key Down", "Key Press Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_KEY_UP = + EO_EVENT_DESCRIPTION("Key Up", "Key Release Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_FOCUS_IN = + EO_EVENT_DESCRIPTION("Focus In", "Focus In Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_FOCUS_OUT = + EO_EVENT_DESCRIPTION("Focus Out", "Focus Out Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_SHOW = + EO_EVENT_DESCRIPTION("Show", "Show Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_HIDE = + EO_EVENT_DESCRIPTION("Hide", "Hide Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_MOVE = + EO_EVENT_DESCRIPTION("Move", "Move Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_RESIZE = + EO_EVENT_DESCRIPTION("Resize", "Resize Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_RESTACK = + EO_EVENT_DESCRIPTION("Restack", "Restack Event"); +EAPI const Eo_Event_Description _EVAS_EVENT_DEL = + EO_EVENT_DESCRIPTION("Del", "Object Being Deleted (called before Free)"); +EAPI const Eo_Event_Description _EVAS_EVENT_HOLD = + EO_EVENT_DESCRIPTION("Hold", "Events go on/off hold"); +EAPI const Eo_Event_Description _EVAS_EVENT_CHANGED_SIZE_HINTS = + EO_EVENT_DESCRIPTION("Changed Size Hints", "Size hints changed event"); +EAPI const Eo_Event_Description _EVAS_EVENT_IMAGE_PRELOADED = + EO_EVENT_DESCRIPTION("Image Preloaded", "Image has been preloaded"); +EAPI const Eo_Event_Description _EVAS_EVENT_IMAGE_RESIZE= + EO_EVENT_DESCRIPTION("Image Resize", "Image resize"); +EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_IN = + EO_EVENT_DESCRIPTION("Canvas Focus In", "Canvas got focus as a whole"); +EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_OUT = + EO_EVENT_DESCRIPTION("Canvas Focus Out", "Canvas lost focus as a whole"); +EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_PRE = + EO_EVENT_DESCRIPTION("Render Flush Pre", "Called just before rendering is updated on the canvas target"); +EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_POST = + EO_EVENT_DESCRIPTION("Render Flush Post", "Called just after rendering is updated on the canvas target"); +EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN = + EO_EVENT_DESCRIPTION("Canvas Object Focus In", "Canvas object got focus"); +EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT = + EO_EVENT_DESCRIPTION("Canvas Object Focus Out", "Canvas object lost focus"); +EAPI const Eo_Event_Description _EVAS_EVENT_IMAGE_UNLOADED = + EO_EVENT_DESCRIPTION("Image Unloaded", "Image data has been unloaded (by some mechanism in Evas that throw out original image data)"); +EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_PRE = + EO_EVENT_DESCRIPTION("Render Pre", "Called just before rendering starts on the canvas target @since 1.2"); +EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_POST = + EO_EVENT_DESCRIPTION("Render Post", "Called just after rendering stops on the canvas target @since 1.2"); + +/** + * Evas events descriptions for Eo. + */ +static const Eo_Event_Description *_legacy_evas_callback_table[EVAS_CALLBACK_LAST] = +{ + EVAS_EVENT_MOUSE_IN, + EVAS_EVENT_MOUSE_OUT, + EVAS_EVENT_MOUSE_DOWN, + EVAS_EVENT_MOUSE_UP, + EVAS_EVENT_MOUSE_MOVE, + EVAS_EVENT_MOUSE_WHEEL, + EVAS_EVENT_MULTI_DOWN, + EVAS_EVENT_MULTI_UP, + EVAS_EVENT_MULTI_MOVE, + EVAS_EVENT_FREE, + EVAS_EVENT_KEY_DOWN, + EVAS_EVENT_KEY_UP, + EVAS_EVENT_FOCUS_IN, + EVAS_EVENT_FOCUS_OUT, + EVAS_EVENT_SHOW, + EVAS_EVENT_HIDE, + EVAS_EVENT_MOVE, + EVAS_EVENT_RESIZE, + EVAS_EVENT_RESTACK, + EVAS_EVENT_DEL, + EVAS_EVENT_HOLD, + EVAS_EVENT_CHANGED_SIZE_HINTS, + EVAS_EVENT_IMAGE_PRELOADED, + EVAS_EVENT_IMAGE_RESIZE, + EVAS_EVENT_CANVAS_FOCUS_IN, + EVAS_EVENT_CANVAS_FOCUS_OUT, + EVAS_EVENT_RENDER_FLUSH_PRE, + EVAS_EVENT_RENDER_FLUSH_POST, + EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN, + EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT, + EVAS_EVENT_IMAGE_UNLOADED, + EVAS_EVENT_RENDER_PRE, + EVAS_EVENT_RENDER_POST +}; + void -_evas_post_event_callback_call(Evas *e) +_evas_post_event_callback_call(Evas *eo_e, Evas_Public_Data *e) { Evas_Post_Callback *pc; int skip = 0; @@ -21,7 +130,7 @@ _evas_post_event_callback_call(Evas *e) { if ((!skip) && (!e->delete_me) && (!pc->delete_me)) { - if (!pc->func((void*)pc->data, e)) skip = 1; + if (!pc->func((void*)pc->data, eo_e)) skip = 1; } EVAS_MEMPOOL_FREE(_mp_pc, pc); } @@ -29,8 +138,9 @@ _evas_post_event_callback_call(Evas *e) } void -_evas_post_event_callback_free(Evas *e) +_evas_post_event_callback_free(Evas *eo_e) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Post_Callback *pc; EINA_LIST_FREE(e->post_events, pc) @@ -60,8 +170,9 @@ evas_event_callback_list_post_free(Eina_Inlist **list) } static void -evas_object_event_callback_clear(Evas_Object *obj) +evas_object_event_callback_clear(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->callbacks) return; if (!obj->callbacks->deletions_waiting) return; obj->callbacks->deletions_waiting = 0; @@ -74,8 +185,9 @@ evas_object_event_callback_clear(Evas_Object *obj) } static void -evas_event_callback_clear(Evas *e) +evas_event_callback_clear(Evas *eo_e) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); if (!e->callbacks) return; if (!e->callbacks->deletions_waiting) return; e->callbacks->deletions_waiting = 0; @@ -88,9 +200,10 @@ evas_event_callback_clear(Evas *e) } void -evas_object_event_callback_all_del(Evas_Object *obj) +evas_object_event_callback_all_del(Evas_Object *eo_obj) { Evas_Func_Node *fn; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->callbacks) return; EINA_INLIST_FOREACH(obj->callbacks->callbacks, fn) @@ -98,9 +211,10 @@ evas_object_event_callback_all_del(Evas_Object *obj) } void -evas_object_event_callback_cleanup(Evas_Object *obj) +evas_object_event_callback_cleanup(Evas_Object *eo_obj) { /* MEM OK */ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->callbacks) return; evas_event_callback_list_post_free(&obj->callbacks->callbacks); EVAS_MEMPOOL_FREE(_mp_cb, obj->callbacks); @@ -108,8 +222,9 @@ evas_object_event_callback_cleanup(Evas_Object *obj) } void -evas_event_callback_all_del(Evas *e) +evas_event_callback_all_del(Evas *eo_e) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Func_Node *fn; if (!e->callbacks) return; @@ -118,8 +233,9 @@ evas_event_callback_all_del(Evas *e) } void -evas_event_callback_cleanup(Evas *e) +evas_event_callback_cleanup(Evas *eo_e) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); /* MEM OK */ if (!e->callbacks) return; evas_event_callback_list_post_free(&e->callbacks->callbacks); @@ -128,8 +244,9 @@ evas_event_callback_cleanup(Evas *e) } void -evas_event_callback_call(Evas *e, Evas_Callback_Type type, void *event_info) +evas_event_callback_call(Evas *eo_e, Evas_Callback_Type type, void *event_info) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Eina_Inlist **l_mod = NULL, *l; _evas_walk(e); @@ -146,14 +263,14 @@ evas_event_callback_call(Evas *e, Evas_Callback_Type type, void *event_info) { Evas_Event_Cb func = fn->func; if (func) - func(fn->data, e, event_info); + func(fn->data, eo_e, event_info); } if (e->delete_me) break; } e->callbacks->walking_list--; if (!e->callbacks->walking_list) { - evas_event_callback_clear(e); + evas_event_callback_clear(eo_e); l_mod = NULL; } } @@ -161,12 +278,12 @@ evas_event_callback_call(Evas *e, Evas_Callback_Type type, void *event_info) } void -evas_object_event_callback_call(Evas_Object *obj, Evas_Callback_Type type, void *event_info, int event_id) +evas_object_event_callback_call(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Callback_Type type, void *event_info, int event_id) { /* MEM OK */ Eina_Inlist **l_mod = NULL, *l; Evas_Button_Flags flags = EVAS_BUTTON_NONE; - Evas *e; + Evas_Public_Data *e; if ((obj->delete_me) || (!obj->layer)) return; if ((obj->last_event == event_id) && @@ -229,17 +346,21 @@ evas_object_event_callback_call(Evas_Object *obj, Evas_Callback_Type type, void { Evas_Object_Event_Cb func = fn->func; if (func) - func(fn->data, obj->layer->evas, obj, event_info); + func(fn->data, obj->layer->evas->evas, eo_obj, event_info); } if (obj->delete_me) break; } obj->callbacks->walking_list--; if (!obj->callbacks->walking_list) { - evas_object_event_callback_clear(obj); + evas_object_event_callback_clear(eo_obj); l_mod = NULL; } + const Eo_Event_Description *event_desc = eina_hash_find(signals_hash_table, _legacy_evas_callback_table[type]->name); + if (event_desc) + eo_do(eo_obj, eo_event_callback_call(_legacy_evas_callback_table[type], event_info, NULL)); + if (type == EVAS_CALLBACK_MOUSE_DOWN) { Evas_Event_Mouse_Down *ev = event_info; @@ -258,7 +379,10 @@ evas_object_event_callback_call(Evas_Object *obj, Evas_Callback_Type type, void { if ((obj->smart.parent) && (type != EVAS_CALLBACK_FREE) && (type <= EVAS_CALLBACK_KEY_UP)) - evas_object_event_callback_call(obj->smart.parent, type, event_info, event_id); + { + Evas_Object_Protected_Data *smart_parent = eo_data_get(obj->smart.parent, EVAS_OBJ_CLASS); + evas_object_event_callback_call(obj->smart.parent, smart_parent, type, event_info, event_id); + } } } _evas_unwalk(e); @@ -277,19 +401,20 @@ _callback_priority_cmp(const void *_a, const void *_b) } EAPI void -evas_object_event_callback_add(Evas_Object *obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data) +evas_object_event_callback_add(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data) { - evas_object_event_callback_priority_add(obj, type, + evas_object_event_callback_priority_add(eo_obj, type, EVAS_CALLBACK_PRIORITY_DEFAULT, func, data); } EAPI void -evas_object_event_callback_priority_add(Evas_Object *obj, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Object_Event_Cb func, const void *data) +evas_object_event_callback_priority_add(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Object_Event_Cb func, const void *data) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* MEM OK */ Evas_Func_Node *fn; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); @@ -318,14 +443,15 @@ evas_object_event_callback_priority_add(Evas_Object *obj, Evas_Callback_Type typ } EAPI void * -evas_object_event_callback_del(Evas_Object *obj, Evas_Callback_Type type, Evas_Object_Event_Cb func) +evas_object_event_callback_del(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func) { /* MEM OK */ Evas_Func_Node *fn; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return NULL; @@ -341,7 +467,7 @@ evas_object_event_callback_del(Evas_Object *obj, Evas_Callback_Type type, Evas_O fn->delete_me = 1; obj->callbacks->deletions_waiting = 1; if (!obj->callbacks->walking_list) - evas_object_event_callback_clear(obj); + evas_object_event_callback_clear(eo_obj); return tmp; } } @@ -349,14 +475,15 @@ evas_object_event_callback_del(Evas_Object *obj, Evas_Callback_Type type, Evas_O } EAPI void * -evas_object_event_callback_del_full(Evas_Object *obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data) +evas_object_event_callback_del_full(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data) { /* MEM OK */ Evas_Func_Node *fn; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return NULL; @@ -372,7 +499,7 @@ evas_object_event_callback_del_full(Evas_Object *obj, Evas_Callback_Type type, E fn->delete_me = 1; obj->callbacks->deletions_waiting = 1; if (!obj->callbacks->walking_list) - evas_object_event_callback_clear(obj); + evas_object_event_callback_clear(eo_obj); return tmp; } } @@ -380,19 +507,20 @@ evas_object_event_callback_del_full(Evas_Object *obj, Evas_Callback_Type type, E } EAPI void -evas_event_callback_add(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data) +evas_event_callback_add(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data) { - evas_event_callback_priority_add(e, type, EVAS_CALLBACK_PRIORITY_DEFAULT, + evas_event_callback_priority_add(eo_e, type, EVAS_CALLBACK_PRIORITY_DEFAULT, func, data); } EAPI void -evas_event_callback_priority_add(Evas *e, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Event_Cb func, const void *data) +evas_event_callback_priority_add(Evas *eo_e, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Event_Cb func, const void *data) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); /* MEM OK */ Evas_Func_Node *fn; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); @@ -420,12 +548,13 @@ evas_event_callback_priority_add(Evas *e, Evas_Callback_Type type, Evas_Callback } EAPI void * -evas_event_callback_del(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func) +evas_event_callback_del(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); /* MEM OK */ Evas_Func_Node *fn; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); @@ -443,7 +572,7 @@ evas_event_callback_del(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func) fn->delete_me = 1; e->callbacks->deletions_waiting = 1; if (!e->callbacks->walking_list) - evas_event_callback_clear(e); + evas_event_callback_clear(eo_e); return data; } } @@ -451,14 +580,15 @@ evas_event_callback_del(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func) } EAPI void * -evas_event_callback_del_full(Evas *e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data) +evas_event_callback_del_full(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data) { /* MEM OK */ Evas_Func_Node *fn; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); if (!func) return NULL; @@ -474,7 +604,7 @@ evas_event_callback_del_full(Evas *e, Evas_Callback_Type type, Evas_Event_Cb fun fn->delete_me = 1; e->callbacks->deletions_waiting = 1; if (!e->callbacks->walking_list) - evas_event_callback_clear(e); + evas_event_callback_clear(eo_e); return tmp; } } @@ -482,14 +612,15 @@ evas_event_callback_del_full(Evas *e, Evas_Callback_Type type, Evas_Event_Cb fun } EAPI void -evas_post_event_callback_push(Evas *e, Evas_Object_Event_Post_Cb func, const void *data) +evas_post_event_callback_push(Evas *eo_e, Evas_Object_Event_Post_Cb func, const void *data) { Evas_Post_Callback *pc; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); EVAS_MEMPOOL_INIT(_mp_pc, "evas_post_callback", Evas_Post_Callback, 64, ); pc = EVAS_MEMPOOL_ALLOC(_mp_pc, Evas_Post_Callback); if (!pc) return; @@ -502,15 +633,16 @@ evas_post_event_callback_push(Evas *e, Evas_Object_Event_Post_Cb func, const voi } EAPI void -evas_post_event_callback_remove(Evas *e, Evas_Object_Event_Post_Cb func) +evas_post_event_callback_remove(Evas *eo_e, Evas_Object_Event_Post_Cb func) { Evas_Post_Callback *pc; Eina_List *l; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); EINA_LIST_FOREACH(e->post_events, l, pc) { if (pc->func == func) @@ -522,15 +654,16 @@ evas_post_event_callback_remove(Evas *e, Evas_Object_Event_Post_Cb func) } EAPI void -evas_post_event_callback_remove_full(Evas *e, Evas_Object_Event_Post_Cb func, const void *data) +evas_post_event_callback_remove_full(Evas *eo_e, Evas_Object_Event_Post_Cb func, const void *data) { Evas_Post_Callback *pc; Eina_List *l; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); EINA_LIST_FOREACH(e->post_events, l, pc) { if ((pc->func == func) && (pc->data == data)) diff --git a/legacy/evas/src/lib/canvas/evas_clip.c b/legacy/evas/src/lib/canvas/evas_clip.c index f1e9de339a..d412e435fa 100644 --- a/legacy/evas/src/lib/canvas/evas_clip.c +++ b/legacy/evas/src/lib/canvas/evas_clip.c @@ -2,7 +2,7 @@ #include "evas_private.h" void -evas_object_clip_dirty(Evas_Object *obj) +evas_object_clip_dirty(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { Eina_List *l; Evas_Object *data; @@ -10,32 +10,43 @@ evas_object_clip_dirty(Evas_Object *obj) if (obj->cur.cache.clip.dirty) return; obj->cur.cache.clip.dirty = 1; + Evas_Object_Protected_Data *clipee = NULL; EINA_LIST_FOREACH(obj->clip.clipees, l, data) - evas_object_clip_dirty(data); + { + clipee = eo_data_get(data, EVAS_OBJ_CLASS); + evas_object_clip_dirty(data, clipee); + } } void -evas_object_recalc_clippees(Evas_Object *obj) +evas_object_recalc_clippees(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { Eina_List *l; Evas_Object *data; if (obj->cur.cache.clip.dirty) { - evas_object_clip_recalc(obj); + evas_object_clip_recalc(eo_obj, obj); EINA_LIST_FOREACH(obj->clip.clipees, l, data) - evas_object_recalc_clippees(data); + { + Evas_Object_Protected_Data *clipee = eo_data_get(data, EVAS_OBJ_CLASS); + evas_object_recalc_clippees(data, clipee); + } } } int -evas_object_clippers_was_visible(Evas_Object *obj) +evas_object_clippers_was_visible(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { if (obj->prev.visible) { - if (obj->prev.clipper) - return evas_object_clippers_is_visible(obj->prev.clipper); - return 1; + if (obj->prev.clipper) + { + Evas_Object_Protected_Data *prev_clipper = + eo_data_get(obj->prev.clipper, EVAS_OBJ_CLASS); + return evas_object_clippers_is_visible(obj->prev.clipper, prev_clipper); + } + return 1; } return 0; } @@ -76,63 +87,71 @@ evas_object_clippers_was_visible(Evas_Object *obj) #define MAP_ACROSS 1 static void -evas_object_child_map_across_mark(Evas_Object *obj, Evas_Object *map_obj, Eina_Bool force) +evas_object_child_map_across_mark(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object *map_obj, Eina_Bool force) { #ifdef MAP_ACROSS if ((obj->cur.map_parent != map_obj) || force) { obj->cur.map_parent = map_obj; obj->cur.cache.clip.dirty = 1; - evas_object_clip_recalc(obj); - if (obj->smart.smart) + evas_object_clip_recalc(eo_obj, obj); + if (obj->is_smart) { - Evas_Object *obj2; + Evas_Object_Protected_Data *obj2; - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), obj2) + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2) { // if obj has its own map - skip it. already done if ((obj2->cur.map) && (obj2->cur.usemap)) continue; - evas_object_child_map_across_mark(obj2, map_obj, force); + Evas_Object *eo_obj2 = obj2->object; + evas_object_child_map_across_mark(eo_obj2, obj2, map_obj, force); } } else if (obj->clip.clipees) { Eina_List *l; - Evas_Object *obj2; + Evas_Object *eo_obj2; - EINA_LIST_FOREACH(obj->clip.clipees, l, obj2) - evas_object_child_map_across_mark(obj2, map_obj, force); + EINA_LIST_FOREACH(obj->clip.clipees, l, eo_obj2) + { + Evas_Object_Protected_Data *obj2 = eo_data_get(eo_obj2, EVAS_OBJ_CLASS); + evas_object_child_map_across_mark(eo_obj2, obj2, map_obj, force); + } } } #endif } void -evas_object_clip_across_check(Evas_Object *obj) +evas_object_clip_across_check(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { #ifdef MAP_ACROSS if (!obj->cur.clipper) return; - if (obj->cur.clipper->cur.map_parent != obj->cur.map_parent) - evas_object_child_map_across_mark(obj, obj->cur.map_parent, 1); + Evas_Object_Protected_Data *clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + if (clipper->cur.map_parent != obj->cur.map_parent) + evas_object_child_map_across_mark(eo_obj, obj, obj->cur.map_parent, 1); #endif } void -evas_object_clip_across_clippees_check(Evas_Object *obj) +evas_object_clip_across_clippees_check(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { #ifdef MAP_ACROSS Eina_List *l; - Evas_Object *obj2; + Evas_Object *eo_obj2; if (!obj->clip.clipees) return; // schloooooooooooow: -// evas_object_child_map_across_mark(obj, obj->cur.map_parent, 1); +// evas_object_child_map_across_mark(eo_obj, obj->cur.map_parent, 1); // buggy: - evas_object_child_map_across_mark(obj, obj->cur.map_parent, 0); + evas_object_child_map_across_mark(eo_obj, obj, obj->cur.map_parent, 0); if (obj->cur.cache.clip.dirty) { - EINA_LIST_FOREACH(obj->clip.clipees, l, obj2) - evas_object_clip_across_clippees_check(obj2); + EINA_LIST_FOREACH(obj->clip.clipees, l, eo_obj2) + { + Evas_Object_Protected_Data *obj2 = eo_data_get(eo_obj2, EVAS_OBJ_CLASS); + evas_object_clip_across_clippees_check(eo_obj2, obj2); + } } #endif } @@ -142,19 +161,23 @@ evas_object_clip_across_clippees_check(Evas_Object *obj) // // FIXME: flip2 test broken in elm - might be show/hide of clips void -evas_object_mapped_clip_across_mark(Evas_Object *obj) +evas_object_mapped_clip_across_mark(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { #ifdef MAP_ACROSS if ((obj->cur.map) && (obj->cur.usemap)) - evas_object_child_map_across_mark(obj, obj, 0); + evas_object_child_map_across_mark(eo_obj, obj, eo_obj, 0); else { if (obj->smart.parent) - evas_object_child_map_across_mark - (obj, obj->smart.parent->cur.map_parent, 0); + { + Evas_Object_Protected_Data *smart_parent_obj = + eo_data_get(obj->smart.parent, EVAS_OBJ_CLASS); + evas_object_child_map_across_mark + (eo_obj, obj, smart_parent_obj->cur.map_parent, 0); + } else - evas_object_child_map_across_mark(obj, NULL, 0); - } + evas_object_child_map_across_mark(eo_obj, obj, NULL, 0); + } #endif } @@ -162,40 +185,51 @@ evas_object_mapped_clip_across_mark(Evas_Object *obj) extern const char *o_rect_type; EAPI void -evas_object_clip_set(Evas_Object *obj, Evas_Object *clip) +evas_object_clip_set( + Evas_Object *eo_obj, + Evas_Object *clip) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - if (!clip) + eo_do(eo_obj, evas_obj_clip_set(clip)); +} + +void +_clip_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object *eo_clip = va_arg(*list, Evas_Object *); + Evas_Object_Protected_Data *obj = _pd; + if (!eo_clip) { - evas_object_clip_unset(obj); + evas_object_clip_unset(eo_obj); return; } - MAGIC_CHECK(clip, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_clip, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - if (obj->cur.clipper == clip) return; - if (obj == clip) + Evas_Object_Protected_Data *clip = eo_data_get(eo_clip, EVAS_OBJ_CLASS); + if (obj->cur.clipper == eo_clip) return; + if (eo_obj == eo_clip) { - CRIT("Setting clip %p on itself", obj); + CRIT("Setting clip %p on itself", eo_obj); return; } if (clip->delete_me) { - CRIT("Setting deleted object %p as clip obj %p", clip, obj); + CRIT("Setting deleted object %p as clip obj %p", eo_clip, eo_obj); abort(); return; } if (obj->delete_me) { - CRIT("Setting object %p as clip to deleted obj %p", clip, obj); + CRIT("Setting object %p as clip to deleted obj %p", eo_clip, eo_obj); abort(); return; } if (!obj->layer) { - CRIT("No evas surface associated with object (%p)", obj); + CRIT("No evas surface associated with object (%p)", eo_obj); abort(); return; } @@ -207,34 +241,34 @@ evas_object_clip_set(Evas_Object *obj, Evas_Object *clip) return; } - if (evas_object_intercept_call_clip_set(obj, clip)) return; + if (evas_object_intercept_call_clip_set(eo_obj, obj, eo_clip)) return; // illegal to set anything but a rect as a clip if (clip->type != o_rect_type) { ERR("For now a clip on other object than a rectangle is disabled"); return; } - if (obj->smart.smart) + if (obj->is_smart) { - if (obj->smart.smart->smart_class->clip_set) - obj->smart.smart->smart_class->clip_set(obj, clip); + eo_do(eo_obj, evas_obj_smart_clip_set(eo_clip)); } if (obj->cur.clipper) { - /* unclip */ - obj->cur.clipper->clip.clipees = eina_list_remove(obj->cur.clipper->clip.clipees, obj); - if (!obj->cur.clipper->clip.clipees) + /* unclip */ + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + cur_clipper->clip.clipees = eina_list_remove(cur_clipper->clip.clipees, eo_obj); + if (!cur_clipper->clip.clipees) { - obj->cur.clipper->cur.have_clipees = 0; - if (obj->cur.clipper->cur.visible) - evas_damage_rectangle_add(obj->cur.clipper->layer->evas, - obj->cur.clipper->cur.geometry.x, - obj->cur.clipper->cur.geometry.y, - obj->cur.clipper->cur.geometry.w, - obj->cur.clipper->cur.geometry.h); + cur_clipper->cur.have_clipees = 0; + if (cur_clipper->cur.visible) + evas_damage_rectangle_add(cur_clipper->layer->evas->evas, + cur_clipper->cur.geometry.x, + cur_clipper->cur.geometry.y, + cur_clipper->cur.geometry.w, + cur_clipper->cur.geometry.h); } - evas_object_change(obj->cur.clipper); - evas_object_change(obj); + evas_object_change(obj->cur.clipper, cur_clipper); + evas_object_change(eo_obj, obj); obj->cur.clipper = NULL; } /* clip me */ @@ -243,115 +277,142 @@ evas_object_clip_set(Evas_Object *obj, Evas_Object *clip) /* Basically it just went invisible */ clip->changed = 1; clip->layer->evas->changed = 1; - evas_damage_rectangle_add(clip->layer->evas, + evas_damage_rectangle_add(clip->layer->evas->evas, clip->cur.geometry.x, clip->cur.geometry.y, clip->cur.geometry.w, clip->cur.geometry.h); } - obj->cur.clipper = clip; - clip->clip.clipees = eina_list_append(clip->clip.clipees, obj); + obj->cur.clipper = eo_clip; + clip->clip.clipees = eina_list_append(clip->clip.clipees, eo_obj); if (clip->clip.clipees) { clip->cur.have_clipees = 1; if (clip->changed) - evas_object_update_bounding_box(clip); + evas_object_update_bounding_box(eo_clip, clip); } /* If it's NOT a rectangle set the mask bits too */ /* FIXME: Optmz ths chck */ if (clip->type == o_rect_type) - obj->cur.mask = NULL; + obj->cur.mask = NULL; else { void *engdata; - obj->cur.mask = clip; - engdata = clip->func->engine_data_get(clip); + obj->cur.mask = eo_clip; + engdata = clip->func->engine_data_get(eo_clip); /* FIXME: Images only */ clip->layer->evas->engine.func->image_mask_create( clip->layer->evas->engine.data.output, engdata); } - evas_object_change(clip); - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_recalc_clippees(obj); - if ((!obj->smart.smart) && + evas_object_change(eo_clip, clip); + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_recalc_clippees(eo_obj, obj); + if ((!obj->is_smart) && (!((obj->cur.map) && (obj->cur.usemap)))) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1)) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } - evas_object_clip_across_check(obj); + evas_object_clip_across_check(eo_obj, obj); } EAPI Evas_Object * -evas_object_clip_get(const Evas_Object *obj) +evas_object_clip_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - return obj->cur.clipper; + Evas_Object *clip = NULL; + eo_do((Eo *)eo_obj, evas_obj_clip_get(&clip)); + return clip; +} + +void +_clip_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object **clip = va_arg(*list, Evas_Object **); + const Evas_Object_Protected_Data *obj = _pd; + *clip = obj->cur.clipper; } EAPI void -evas_object_clip_unset(Evas_Object *obj) +evas_object_clip_unset(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_clip_unset()); +} + +void +_clip_unset(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = _pd; if (!obj->cur.clipper) return; /* unclip */ - if (evas_object_intercept_call_clip_unset(obj)) return; - if (obj->smart.smart) + if (evas_object_intercept_call_clip_unset(eo_obj)) return; + if (obj->is_smart) { - if (obj->smart.smart->smart_class->clip_unset) - obj->smart.smart->smart_class->clip_unset(obj); + eo_do(eo_obj, evas_obj_smart_clip_unset()); } if (obj->cur.clipper) { - obj->cur.clipper->clip.clipees = eina_list_remove(obj->cur.clipper->clip.clipees, obj); - if (!obj->cur.clipper->clip.clipees) + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + cur_clipper->clip.clipees = eina_list_remove(cur_clipper->clip.clipees, eo_obj); + if (!cur_clipper->clip.clipees) { - obj->cur.clipper->cur.have_clipees = 0; - if (obj->cur.clipper->cur.visible) - evas_damage_rectangle_add(obj->cur.clipper->layer->evas, - obj->cur.clipper->cur.geometry.x, - obj->cur.clipper->cur.geometry.y, - obj->cur.clipper->cur.geometry.w, - obj->cur.clipper->cur.geometry.h); + cur_clipper->cur.have_clipees = 0; + if (cur_clipper->cur.visible) + evas_damage_rectangle_add(cur_clipper->layer->evas->evas, + cur_clipper->cur.geometry.x, + cur_clipper->cur.geometry.y, + cur_clipper->cur.geometry.w, + cur_clipper->cur.geometry.h); } - evas_object_change(obj->cur.clipper); + evas_object_change(obj->cur.clipper, cur_clipper); } obj->cur.clipper = NULL; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_recalc_clippees(obj); - if ((!obj->smart.smart) && + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_recalc_clippees(eo_obj, obj); + if ((!obj->is_smart) && (!((obj->cur.map) && (obj->cur.usemap)))) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1)) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } - evas_object_clip_across_check(obj); + evas_object_clip_across_check(eo_obj, obj); } EAPI const Eina_List * -evas_object_clipees_get(const Evas_Object *obj) +evas_object_clipees_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - return obj->clip.clipees; + const Eina_List *clipees = NULL; + eo_do((Eo *)eo_obj, evas_obj_clipees_get(&clipees)); + return clipees; +} + +void +_clipees_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Eina_List **clipees = va_arg(*list, const Eina_List **); + const Evas_Object_Protected_Data *obj = _pd; + *clipees = obj->clip.clipees; } diff --git a/legacy/evas/src/lib/canvas/evas_common_interface.c b/legacy/evas/src/lib/canvas/evas_common_interface.c new file mode 100644 index 0000000000..8f16d5ae73 --- /dev/null +++ b/legacy/evas/src/lib/canvas/evas_common_interface.c @@ -0,0 +1,24 @@ +#include "evas_common.h" +#include "evas_private.h" + +#include "Eo.h" + +EAPI Eo_Op EVAS_COMMON_BASE_ID = EO_NOOP; + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_COMMON_SUB_ID_EVAS_GET, "Return the evas parent attached to the object"), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Common_Interface", + EO_CLASS_TYPE_INTERFACE, + EO_CLASS_DESCRIPTION_OPS(&EVAS_COMMON_BASE_ID, op_desc, EVAS_COMMON_SUB_ID_LAST), + NULL, + 0, + NULL, + NULL, +}; + +EO_DEFINE_CLASS(evas_common_class_get, &class_desc, NULL, NULL) diff --git a/legacy/evas/src/lib/canvas/evas_data.c b/legacy/evas/src/lib/canvas/evas_data.c index 3ac9d63577..1d1d69829d 100644 --- a/legacy/evas/src/lib/canvas/evas_data.c +++ b/legacy/evas/src/lib/canvas/evas_data.c @@ -5,68 +5,30 @@ EAPI void evas_object_data_set(Evas_Object *obj, const char *key, const void *data) { - Evas_Data_Node *node; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - if (!key) return; - - evas_object_data_del(obj, key); - if (!data) return; - node = malloc(sizeof(Evas_Data_Node) + strlen(key) + 1); - node->key = (char *)node + sizeof(Evas_Data_Node); - strcpy(node->key, key); - node->data = (void *)data; - obj->data.elements = eina_list_prepend(obj->data.elements, node); + eo_do(obj, eo_base_data_set(key, data, NULL)); } EAPI void * evas_object_data_get(const Evas_Object *obj, const char *key) { - Eina_List *l; - Evas_Data_Node *node; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - if (!key) return NULL; - - EINA_LIST_FOREACH(obj->data.elements, l, node) - { - if (!strcmp(node->key, key)) - { - Eina_List *lst; - lst = obj->data.elements; - lst = eina_list_promote_list(lst, l); - ((Evas_Object *)obj)->data.elements = lst; - return node->data; - } - } - return NULL; + void *data = NULL; + eo_do((Evas_Object *)obj, eo_base_data_get(key, &data)); + return data; } EAPI void * evas_object_data_del(Evas_Object *obj, const char *key) { - Eina_List *l; - Evas_Data_Node *node; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - if (!key) return NULL; - EINA_LIST_FOREACH(obj->data.elements, l, node) - { - if (!strcmp(node->key, key)) - { - void *data; - - data = node->data; - obj->data.elements = eina_list_remove_list(obj->data.elements, l); - free(node); - return data; - } - } - return NULL; + void *data = NULL; + eo_do(obj, eo_base_data_get(key, &data), eo_base_data_del(key)); + return data; } diff --git a/legacy/evas/src/lib/canvas/evas_device.c b/legacy/evas/src/lib/canvas/evas_device.c index 95204be77b..8569bd5d02 100644 --- a/legacy/evas/src/lib/canvas/evas_device.c +++ b/legacy/evas/src/lib/canvas/evas_device.c @@ -2,20 +2,21 @@ #include "evas_private.h" EAPI Evas_Device * -evas_device_new(Evas *e) +evas_device_new(Evas *eo_e) { Evas_Device *dev; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); dev = calloc(1, sizeof(Evas_Device)); if (!dev) return NULL; dev->magic = MAGIC_DEV; - dev->evas = e; + dev->evas = eo_e; dev->ref = 1; + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); e->devices = eina_list_append(e->devices, dev); - evas_event_callback_call(e, EVAS_CALLBACK_DEVICE_CHANGED, dev); + evas_event_callback_call(eo_e, EVAS_CALLBACK_DEVICE_CHANGED, dev); return dev; } @@ -45,14 +46,15 @@ evas_device_free(Evas_Device *dev) } EAPI void -evas_device_push(Evas *e, Evas_Device *dev) +evas_device_push(Evas *eo_e, Evas_Device *dev) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); MAGIC_CHECK(dev, Evas_Device, MAGIC_DEV); return; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); if (!e->cur_device) { e->cur_device = eina_array_new(4); @@ -63,21 +65,22 @@ evas_device_push(Evas *e, Evas_Device *dev) } EAPI void -evas_device_pop(Evas *e) +evas_device_pop(Evas *eo_e) { Evas_Device *dev; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); dev = eina_array_pop(e->cur_device); if (dev) _evas_device_unref(dev); } EAPI const Eina_List * -evas_device_list(Evas *e, const Evas_Device *dev) +evas_device_list(Evas *eo_e, const Evas_Device *dev) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); if (dev) @@ -87,6 +90,7 @@ evas_device_list(Evas *e, const Evas_Device *dev) MAGIC_CHECK_END(); } if (dev) return dev->children; + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); return e->devices; } @@ -206,10 +210,11 @@ evas_device_emulation_source_get(const Evas_Device *dev) } void -_evas_device_cleanup(Evas *e) +_evas_device_cleanup(Evas *eo_e) { Evas_Device *dev; + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); if (e->cur_device) { while ((dev = eina_array_pop(e->cur_device))) @@ -224,10 +229,11 @@ _evas_device_cleanup(Evas *e) } Evas_Device * -_evas_device_top_get(const Evas *e) +_evas_device_top_get(const Evas *eo_e) { int num; + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); if (!e->cur_device) return NULL; num = eina_array_count(e->cur_device); if (num < 1) return NULL; diff --git a/legacy/evas/src/lib/canvas/evas_events.c b/legacy/evas/src/lib/canvas/evas_events.c index 9a21bac8b0..09d642d96c 100644 --- a/legacy/evas/src/lib/canvas/evas_events.c +++ b/legacy/evas/src/lib/canvas/evas_events.c @@ -2,15 +2,18 @@ #include "evas_private.h" static Eina_List * -_evas_event_object_list_in_get(Evas *e, Eina_List *in, +_evas_event_object_list_in_get(Evas *eo_e, Eina_List *in, const Eina_Inlist *list, Evas_Object *stop, int x, int y, int *no_rep); static void -_evas_event_havemap_adjust(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Eina_Bool mouse_grabbed) +_evas_event_havemap_adjust(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Evas_Coord *x, Evas_Coord *y, Eina_Bool mouse_grabbed) { if (obj->smart.parent) - _evas_event_havemap_adjust(obj->smart.parent, x, y, mouse_grabbed); + { + Evas_Object_Protected_Data *smart_parent_obj = eo_data_get(obj->smart.parent, EVAS_OBJ_CLASS); + _evas_event_havemap_adjust(obj->smart.parent, smart_parent_obj, x, y, mouse_grabbed); + } if ((!obj->cur.usemap) || (!obj->cur.map) || (!obj->cur.map->count == 4)) return; @@ -21,13 +24,14 @@ _evas_event_havemap_adjust(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Eina_ } static void -_evas_event_framespace_adjust(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y) +_evas_event_framespace_adjust(Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (obj->is_frame) return; - if ((!obj->smart.parent) && (obj->smart.smart)) + if ((!obj->smart.parent) && (obj->is_smart)) { - Evas *evas; + Evas_Public_Data *evas; evas = obj->layer->evas; if (x) *x -= evas->framespace.x; @@ -36,36 +40,38 @@ _evas_event_framespace_adjust(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y) } static Eina_List * -_evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, +_evas_event_object_list_raw_in_get(Evas *eo_e, Eina_List *in, const Eina_Inlist *list, Evas_Object *stop, int x, int y, int *no_rep) { - Evas_Object *obj; + Evas_Object *eo_obj; + Evas_Object_Protected_Data *obj; int inside; if (!list) return in; - for (obj = _EINA_INLIST_CONTAINER(obj, list); - obj; + for (obj = _EINA_INLIST_CONTAINER(obj, list); + obj; obj = _EINA_INLIST_CONTAINER(obj, EINA_INLIST_GET(obj)->prev)) { - if (obj == stop) + eo_obj = obj->object; + if (eo_obj == stop) { *no_rep = 1; return in; } - if (evas_event_passes_through(obj)) continue; + if (evas_event_passes_through(eo_obj, obj)) continue; if ((obj->cur.visible) && (obj->delete_me == 0) && (!obj->clip.clipees) && - (evas_object_clippers_is_visible(obj))) + (evas_object_clippers_is_visible(eo_obj, obj))) { - if (obj->smart.smart) + if (obj->is_smart) { int norep = 0; if ((obj->cur.usemap) && (obj->cur.map) && (obj->cur.map->count == 4)) { - inside = evas_object_is_in_output_rect(obj, x, y, 1, 1); + inside = evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1); if (inside) { if (!evas_map_coords_get(obj->cur.map, x, y, @@ -77,8 +83,8 @@ _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, else { in = _evas_event_object_list_in_get - (e, in, - evas_object_smart_members_get_direct(obj), + (eo_e, in, + evas_object_smart_members_get_direct(eo_obj), stop, obj->cur.geometry.x + obj->cur.map->mx, obj->cur.geometry.y + obj->cur.map->my, @@ -89,7 +95,7 @@ _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, else { if (!obj->child_has_map) - evas_object_smart_bouding_box_update(obj); + evas_object_smart_bouding_box_update(eo_obj); if (obj->child_has_map || (obj->cur.bounding_box.x <= x && obj->cur.bounding_box.x + obj->cur.bounding_box.w >= x && @@ -100,7 +106,7 @@ _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, obj->cur.geometry.y <= y && obj->cur.geometry.y + obj->cur.geometry.h >= y)) in = _evas_event_object_list_in_get - (e, in, evas_object_smart_members_get_direct(obj), + (eo_e, in, evas_object_smart_members_get_direct(eo_obj), stop, x, y, &norep); } if (norep) @@ -114,7 +120,7 @@ _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, } else { - inside = evas_object_is_in_output_rect(obj, x, y, 1, 1); + inside = evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1); if (inside) { @@ -130,10 +136,10 @@ _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, } } if (inside && ((!obj->precise_is_inside) || - (evas_object_is_inside(obj, x, y)))) + (evas_object_is_inside(eo_obj, obj, x, y)))) { - if (!evas_event_freezes_through(obj)) - in = eina_list_append(in, obj); + if (!evas_event_freezes_through(eo_obj, obj)) + in = eina_list_append(in, eo_obj); if (!obj->repeat_events) { *no_rep = 1; @@ -148,26 +154,27 @@ _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in, } static Eina_List * -_evas_event_object_list_in_get(Evas *e, Eina_List *in, +_evas_event_object_list_in_get(Evas *eo_e, Eina_List *in, const Eina_Inlist *list, Evas_Object *stop, int x, int y, int *no_rep) { if (!list) return NULL; - return _evas_event_object_list_raw_in_get(e, in, list->last, stop, x, y, + return _evas_event_object_list_raw_in_get(eo_e, in, list->last, stop, x, y, no_rep); } Eina_List * -evas_event_objects_event_list(Evas *e, Evas_Object *stop, int x, int y) +evas_event_objects_event_list(Evas *eo_e, Evas_Object *stop, int x, int y) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Layer *lay; Eina_List *in = NULL; - if ((!e->layers) || (e->events_frozen > 0)) return NULL; + if ((!e->layers) || (e->is_frozen)) return NULL; EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay) { int no_rep = 0; - in = _evas_event_object_list_in_get(e, in, + in = _evas_event_object_list_in_get(eo_e, in, EINA_INLIST_GET(lay->objects), stop, x, y, &no_rep); if (no_rep) return in; @@ -188,98 +195,157 @@ evas_event_list_copy(Eina_List *list) /* public functions */ EAPI void -evas_event_default_flags_set(Evas *e, Evas_Event_Flags flags) +evas_event_default_flags_set(Evas *eo_e, Evas_Event_Flags flags) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_default_flags_set(flags)); +} + +void +_canvas_event_default_flags_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Event_Flags flags = va_arg(*list, Evas_Event_Flags); + Evas_Public_Data *e = _pd; e->default_event_flags = flags; } EAPI Evas_Event_Flags -evas_event_default_flags_get(const Evas *e) +evas_event_default_flags_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return EVAS_EVENT_FLAG_ON_HOLD; MAGIC_CHECK_END(); - return e->default_event_flags; + Evas_Event_Flags flags = EVAS_EVENT_FLAG_ON_HOLD; + eo_do((Eo *)eo_e, evas_canvas_event_default_flags_get(&flags)); + return flags; +} + +void +_canvas_event_default_flags_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Event_Flags *ret = va_arg(*list, Evas_Event_Flags *); + const Evas_Public_Data *e = _pd; + *ret = e->default_event_flags; +} + +static inline void +_canvas_event_thaw_eval_internal(Eo *eo_e, Evas_Public_Data *e) +{ + evas_event_feed_mouse_move(eo_e, e->pointer.x, e->pointer.y, + e->last_timestamp, NULL); } EAPI void -evas_event_freeze(Evas *e) +evas_event_freeze(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - e->events_frozen++; + eo_do(eo_e, eo_event_freeze()); } EAPI void -evas_event_thaw(Evas *e) +evas_event_thaw(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - e->events_frozen--; - if (e->events_frozen == 0) + eo_do(eo_e, eo_event_thaw()); +} + +void +_canvas_event_freeze(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_e, eo_event_freeze()); + Evas_Public_Data *e = _pd; + e->is_frozen = EINA_TRUE; +} + +void +_canvas_event_thaw(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + int fcount = -1; + eo_do_super(eo_e, + eo_event_thaw(), + eo_event_freeze_get(&fcount)); + if (0 == fcount) { + Evas_Public_Data *e = _pd; Evas_Layer *lay; + e->is_frozen = EINA_FALSE; EINA_INLIST_FOREACH((EINA_INLIST_GET(e->layers)), lay) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_FOREACH(lay->objects, obj) { - evas_object_clip_recalc(obj); - evas_object_recalc_clippees(obj); + Evas_Object *eo_obj = obj->object; + evas_object_clip_recalc(eo_obj, obj); + evas_object_recalc_clippees(eo_obj, obj); } } + + _canvas_event_thaw_eval_internal(eo_e, e); } - if (e->events_frozen < 0) - evas_debug_generic(" Thaw of events when already thawed!!!\n"); } EAPI int -evas_event_freeze_get(const Evas *e) +evas_event_freeze_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return e->events_frozen; + int ret = 0; + eo_do((Eo *)eo_e, eo_event_freeze_get(&ret)); + return ret; } EAPI void -evas_event_thaw_eval(Evas *e) +evas_event_thaw_eval(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - if (e->events_frozen != 0) return; - - evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, - e->last_timestamp, NULL); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); + if (0 == evas_event_freeze_get(eo_e)) + { + _canvas_event_thaw_eval_internal(eo_e, e); + } } EAPI void -evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data) +evas_event_feed_mouse_down(Evas *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_feed_mouse_down(b, flags, timestamp, data)); +} + +void +_canvas_event_feed_mouse_down(Eo *eo_e, void *_pd, va_list *list) +{ + int b = va_arg(*list, int); + Evas_Button_Flags flags = va_arg(*list, Evas_Button_Flags); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; Eina_List *l, *copy; Evas_Event_Mouse_Down ev; - Evas_Object *obj; + Evas_Object *eo_obj; int addgrab = 0; int event_id = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); - if ((b < 1) || (b > 32)) return; e->pointer.button |= (1 << (b - 1)); e->pointer.downs++; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_object_event_new(); @@ -296,17 +362,17 @@ evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int ev.flags = flags; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); /* append new touch point to the touch point list */ - _evas_touch_point_append(e, 0, e->pointer.x, e->pointer.y); + _evas_touch_point_append(eo_e, 0, e->pointer.x, e->pointer.y); /* If this is the first finger down, i.e no other fingers pressed, * get a new event list, otherwise, keep the current grabbed list. */ if (e->pointer.mouse_grabbed == 0) { - Eina_List *ins = evas_event_objects_event_list(e, + Eina_List *ins = evas_event_objects_event_list(eo_e, NULL, e->pointer.x, e->pointer.y); @@ -319,8 +385,9 @@ evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int if (e->pointer.downs > 1) addgrab = e->pointer.downs - 1; } copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) || (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) { @@ -333,35 +400,37 @@ evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int } } } - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (obj->delete_me) continue; ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_DOWN, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_DOWN, &ev, event_id); if (e->delete_me) break; if (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) break; } if (copy) eina_list_free(copy); e->last_mouse_down_counter++; - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); /* update touch point's state to EVAS_TOUCH_POINT_STILL */ - _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_STILL); + _evas_touch_point_update(eo_e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_STILL); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } static int -_post_up_handle(Evas *e, unsigned int timestamp, const void *data) +_post_up_handle(Evas *eo_e, unsigned int timestamp, const void *data) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Eina_List *l, *copy, *ins, *ll; Evas_Event_Mouse_Out ev; - Evas_Object *obj; + Evas_Object *eo_obj; int post_called = 0; int event_id = 0; @@ -378,38 +447,39 @@ _post_up_handle(Evas *e, unsigned int timestamp, const void *data) ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); /* get new list of ins */ - ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y); + ins = evas_event_objects_event_list(eo_e, NULL, e->pointer.x, e->pointer.y); /* go thru old list of in objects */ copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, ll, obj) + EINA_LIST_FOREACH(copy, ll, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); - if ((!eina_list_data_find(ins, obj)) || + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + if ((!eina_list_data_find(ins, eo_obj)) || (!e->pointer.inside)) { if (obj->mouse_in) { obj->mouse_in = 0; - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id); } } if (e->delete_me) break; } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (copy) copy = eina_list_free(copy); if (e->pointer.inside) { Evas_Event_Mouse_In ev_in; - Evas_Object *obj_itr; + Evas_Object *eo_obj_itr; _evas_object_event_new(); @@ -425,25 +495,26 @@ _post_up_handle(Evas *e, unsigned int timestamp, const void *data) ev_in.timestamp = timestamp; ev_in.event_flags = e->default_event_flags; - EINA_LIST_FOREACH(ins, l, obj_itr) + EINA_LIST_FOREACH(ins, l, eo_obj_itr) { + Evas_Object_Protected_Data *obj_itr = eo_data_get(eo_obj_itr, EVAS_OBJ_CLASS); ev_in.canvas.x = e->pointer.x; ev_in.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj_itr, &ev_in.canvas.x, &ev_in.canvas.y); - _evas_event_havemap_adjust(obj_itr, &ev_in.canvas.x, &ev_in.canvas.y, obj_itr->mouse_grabbed); - if (!eina_list_data_find(e->pointer.object.in, obj_itr)) + _evas_event_framespace_adjust(eo_obj_itr, &ev_in.canvas.x, &ev_in.canvas.y); + _evas_event_havemap_adjust(eo_obj_itr, obj_itr, &ev_in.canvas.x, &ev_in.canvas.y, obj_itr->mouse_grabbed); + if (!eina_list_data_find(e->pointer.object.in, eo_obj_itr)) { if (!obj_itr->mouse_in) { obj_itr->mouse_in = 1; - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj_itr, EVAS_CALLBACK_MOUSE_IN, &ev_in, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_IN, &ev_in, event_id); } } if (e->delete_me) break; } post_called = 1; - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); } else { @@ -463,32 +534,44 @@ _post_up_handle(Evas *e, unsigned int timestamp, const void *data) eina_list_free(ins); } if (e->pointer.inside) - evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data); + evas_event_feed_mouse_move(eo_e, e->pointer.x, e->pointer.y, timestamp, data); if (ev.dev) _evas_device_unref(ev.dev); return post_called; } EAPI void -evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data) +evas_event_feed_mouse_up(Evas *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data) { - Eina_List *l, *copy; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_feed_mouse_up(b, flags, timestamp, data)); +} + +void +_canvas_event_feed_mouse_up(Eo *eo_e, void *_pd, va_list *list) +{ + int b = va_arg(*list, int); + Evas_Button_Flags flags = va_arg(*list, Evas_Button_Flags); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; + Eina_List *l, *copy; + if ((b < 1) || (b > 32)) return; if (e->pointer.downs <= 0) return; e->pointer.button &= ~(1 << (b - 1)); e->pointer.downs--; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; { Evas_Event_Mouse_Up ev; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0; _evas_object_event_new(); @@ -505,19 +588,20 @@ evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int t ev.flags = flags; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); /* update released touch point */ - _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_UP); + _evas_touch_point_update(eo_e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_UP); copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) && (obj->mouse_grabbed > 0)) { @@ -526,9 +610,9 @@ evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int t } if (!obj->delete_me) { - if ((e->events_frozen <= 0) && - (!evas_event_freezes_through(obj))) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_UP, &ev, event_id); + if ((!e->is_frozen) && + (!evas_event_freezes_through(eo_obj, obj))) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_UP, &ev, event_id); } if (e->delete_me) break; if (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) @@ -539,13 +623,13 @@ evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int t } if (copy) copy = eina_list_free(copy); e->last_mouse_up_counter++; - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } if (e->pointer.mouse_grabbed == 0) { - _post_up_handle(e, timestamp, data); + _post_up_handle(eo_e, timestamp, data); } if (e->pointer.mouse_grabbed < 0) @@ -554,45 +638,67 @@ evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int t e->pointer.mouse_grabbed); } /* remove released touch point from the touch point list */ - _evas_touch_point_remove(e, 0); - + _evas_touch_point_remove(eo_e, 0); + _evas_unwalk(e); } EAPI void -evas_event_feed_mouse_cancel(Evas *e, unsigned int timestamp, const void *data) +evas_event_feed_mouse_cancel(Evas *eo_e, unsigned int timestamp, const void *data) { - int i; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - if (e->events_frozen > 0) return; + eo_do(eo_e, evas_canvas_event_feed_mouse_cancel(timestamp, data)); +} + +void +_canvas_event_feed_mouse_cancel(Eo *eo_e, void *_pd, va_list *list) +{ + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; + int i; + + if (e->is_frozen) return; _evas_walk(e); for (i = 0; i < 32; i++) { if ((e->pointer.button & (1 << i))) - evas_event_feed_mouse_up(e, i + 1, 0, timestamp, data); + evas_event_feed_mouse_up(eo_e, i + 1, 0, timestamp, data); } // FIXME: multi cancel too? _evas_unwalk(e); } EAPI void -evas_event_feed_mouse_wheel(Evas *e, int direction, int z, unsigned int timestamp, const void *data) +evas_event_feed_mouse_wheel(Evas *eo_e, int direction, int z, unsigned int timestamp, const void *data) { - Eina_List *l, *copy; - Evas_Event_Mouse_Wheel ev; - Evas_Object *obj; - int event_id = 0; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - if (e->events_frozen > 0) return; + eo_do(eo_e, evas_canvas_event_feed_mouse_wheel(direction, z, timestamp, data)); +} + +void +_canvas_event_feed_mouse_wheel(Eo *eo_e, void *_pd, va_list *list) +{ + int direction = va_arg(*list, int); + int z = va_arg(*list, int); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; + Eina_List *l, *copy; + Evas_Event_Mouse_Wheel ev; + Evas_Object *eo_obj; + int event_id = 0; + + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_object_event_new(); @@ -609,59 +715,72 @@ evas_event_feed_mouse_wheel(Evas *e, int direction, int z, unsigned int timestam ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); - if ((e->events_frozen <= 0) && !evas_event_freezes_through(obj)) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_WHEEL, &ev, event_id); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + if ((!e->is_frozen) && !evas_event_freezes_through(eo_obj, obj)) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_WHEEL, &ev, event_id); if (e->delete_me) break; } if (copy) copy = eina_list_free(copy); - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const void *data) +evas_event_feed_mouse_move(Evas *eo_e, int x, int y, unsigned int timestamp, const void *data) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + + eo_do(eo_e, evas_canvas_event_feed_mouse_move(x, y, timestamp, data)); +} + +void +_canvas_event_feed_mouse_move(Eo *eo_e, void *_pd, va_list *list) +{ + int x = va_arg(*list, int); + int y = va_arg(*list, int); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; Evas_Object *nogrep_obj = NULL; int px, py; //// Evas_Coord pcx, pcy; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); - px = e->pointer.x; py = e->pointer.y; //// pcx = e->pointer.canvas_x; //// pcy = e->pointer.canvas_y; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; e->pointer.x = x; e->pointer.y = y; //// e->pointer.canvas_x = x; //// e->pointer.canvas_y = y; -//// e->pointer.canvas_x = evas_coord_screen_x_to_world(e, x); -//// e->pointer.canvas_y = evas_coord_screen_y_to_world(e, y); +//// e->pointer.canvas_x = evas_coord_screen_x_to_world(eo_e, x); +//// e->pointer.canvas_y = evas_coord_screen_y_to_world(eo_e, y); if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return; _evas_walk(e); /* update moved touch point */ if ((px != x) || (py != y)) - _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_MOVE); + _evas_touch_point_update(eo_e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_MOVE); /* if our mouse button is grabbed to any objects */ if (e->pointer.mouse_grabbed > 0) { @@ -671,7 +790,7 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const { Evas_Event_Mouse_Move ev; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0; _evas_object_event_new(); @@ -691,39 +810,40 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.cur.canvas.x = e->pointer.x; ev.cur.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y); - _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, + _evas_event_framespace_adjust(eo_obj, &ev.cur.canvas.x, &ev.cur.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); - if ((e->events_frozen <= 0) && - (evas_object_clippers_is_visible(obj) || + if ((!e->is_frozen) && + (evas_object_clippers_is_visible(eo_obj, obj) || obj->mouse_grabbed) && - (!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj)) && + (!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj)) && (!obj->clip.clipees)) { if ((px != x) || (py != y)) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id); } else - outs = eina_list_append(outs, obj); + outs = eina_list_append(outs, eo_obj); if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) && (e->pointer.nogrep > 0)) { eina_list_free(copy); - nogrep_obj = obj; + nogrep_obj = eo_obj; goto nogrep; } if (e->delete_me) break; } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } { @@ -743,35 +863,36 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); if (copy) eina_list_free(copy); while (outs) { - Evas_Object *obj; + Evas_Object *eo_obj; - obj = outs->data; - outs = eina_list_remove(outs, obj); + eo_obj = outs->data; + outs = eina_list_remove(outs, eo_obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if ((obj->mouse_grabbed == 0) && (!e->delete_me)) { ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); - e->pointer.object.in = eina_list_remove(e->pointer.object.in, obj); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + e->pointer.object.in = eina_list_remove(e->pointer.object.in, eo_obj); if (obj->mouse_in) { obj->mouse_in = 0; if (!obj->delete_me) { - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id); } } } } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } } @@ -782,7 +903,7 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const Evas_Event_Mouse_Move ev; Evas_Event_Mouse_Out ev2; Evas_Event_Mouse_In ev3; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0, event_id2 = 0; _evas_object_event_new(); @@ -802,7 +923,7 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); ev2.buttons = e->pointer.button; @@ -830,32 +951,33 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const ev3.dev = ev.dev; /* get all new in objects */ - ins = evas_event_objects_event_list(e, NULL, x, y); + ins = evas_event_objects_event_list(eo_e, NULL, x, y); /* go thru old list of in objects */ copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* if its under the pointer and its visible and its in the new */ /* in list */ // FIXME: i don't think we need this - // evas_object_clip_recalc(obj); - if ((e->events_frozen <= 0) && - evas_object_is_in_output_rect(obj, x, y, 1, 1) && - (evas_object_clippers_is_visible(obj) || + // evas_object_clip_recalc(eo_obj); + if ((!e->is_frozen) && + evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1) && + (evas_object_clippers_is_visible(eo_obj, obj) || obj->mouse_grabbed) && - eina_list_data_find(ins, obj) && - (!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj)) && + eina_list_data_find(ins, eo_obj) && + (!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj)) && (!obj->clip.clipees) && - ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y)) + ((!obj->precise_is_inside) || evas_object_is_inside(eo_obj, obj, x, y)) ) { if ((px != x) || (py != y)) { ev.cur.canvas.x = e->pointer.x; ev.cur.canvas.y = e->pointer.y; - _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id); + _evas_event_havemap_adjust(eo_obj, obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id); } } /* otherwise it has left the object */ @@ -866,35 +988,36 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const obj->mouse_in = 0; ev2.canvas.x = e->pointer.x; ev2.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev2.canvas.x, &ev2.canvas.y); - _evas_event_havemap_adjust(obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed); - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id); + _evas_event_framespace_adjust(eo_obj, &ev2.canvas.x, &ev2.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id); } } if (e->delete_me) break; } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); _evas_object_event_new(); event_id2 = _evas_event_counter; if (copy) copy = eina_list_free(copy); /* go thru our current list of ins */ - EINA_LIST_FOREACH(ins, l, obj) + EINA_LIST_FOREACH(ins, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev3.canvas.x = e->pointer.x; ev3.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev3.canvas.x, &ev3.canvas.y); - _evas_event_havemap_adjust(obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev3.canvas.x, &ev3.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed); /* if its not in the old list of ins send an enter event */ - if (!eina_list_data_find(e->pointer.object.in, obj)) + if (!eina_list_data_find(e->pointer.object.in, eo_obj)) { if (!obj->mouse_in) { obj->mouse_in = 1; - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2); } } if (e->delete_me) break; @@ -911,7 +1034,7 @@ evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const /* free our cur ins */ eina_list_free(ins); } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } _evas_unwalk(e); @@ -924,7 +1047,7 @@ nogrep: Evas_Event_Mouse_Move ev; Evas_Event_Mouse_Out ev2; Evas_Event_Mouse_In ev3; - Evas_Object *obj, *below_obj; + Evas_Object *eo_obj, *eo_below_obj; int event_id = 0, event_id2 = 0; int norep = 0, breaknext = 0; @@ -945,7 +1068,7 @@ nogrep: ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); ev2.buttons = e->pointer.button; @@ -974,57 +1097,61 @@ nogrep: /* go thru old list of in objects */ copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { if (breaknext) { lst = l; break; } - if (obj == nogrep_obj) breaknext = 1; + if (eo_obj == nogrep_obj) breaknext = 1; } - + /* get all new in objects */ - below_obj = evas_object_below_get(nogrep_obj); - if (below_obj) - ins = _evas_event_object_list_raw_in_get(e, NULL, + eo_below_obj = evas_object_below_get(nogrep_obj); + if (eo_below_obj) + { + Evas_Object_Protected_Data *below_obj = eo_data_get(eo_below_obj, EVAS_OBJ_CLASS); + ins = _evas_event_object_list_raw_in_get(eo_e, NULL, EINA_INLIST_GET(below_obj), NULL, e->pointer.x, e->pointer.y, &norep); - EINA_LIST_FOREACH(copy, l, obj) - { - newin = eina_list_append(newin, obj); - if (obj == nogrep_obj) break; } - EINA_LIST_FOREACH(ins, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { - newin = eina_list_append(newin, obj); + newin = eina_list_append(newin, eo_obj); + if (eo_obj == nogrep_obj) break; + } + EINA_LIST_FOREACH(ins, l, eo_obj) + { + newin = eina_list_append(newin, eo_obj); } - EINA_LIST_FOREACH(lst, l, obj) + EINA_LIST_FOREACH(lst, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* if its under the pointer and its visible and its in the new */ /* in list */ // FIXME: i don't think we need this - // evas_object_clip_recalc(obj); - if ((e->events_frozen <= 0) && - evas_object_is_in_output_rect(obj, x, y, 1, 1) && - (evas_object_clippers_is_visible(obj) || + // evas_object_clip_recalc(eo_obj); + if ((!e->is_frozen) && + evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1) && + (evas_object_clippers_is_visible(eo_obj, obj) || obj->mouse_grabbed) && - eina_list_data_find(newin, obj) && - (!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj)) && + eina_list_data_find(newin, eo_obj) && + (!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj)) && (!obj->clip.clipees) && - ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y)) + ((!obj->precise_is_inside) || evas_object_is_inside(eo_obj, obj, x, y)) ) { if ((px != x) || (py != y)) { ev.cur.canvas.x = e->pointer.x; ev.cur.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y); - _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id); + _evas_event_framespace_adjust(eo_obj, &ev.cur.canvas.x, &ev.cur.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id); } } /* otherwise it has left the object */ @@ -1035,35 +1162,36 @@ nogrep: obj->mouse_in = 0; ev2.canvas.x = e->pointer.x; ev2.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev2.canvas.x, &ev2.canvas.y); - _evas_event_havemap_adjust(obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed); - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id); + _evas_event_framespace_adjust(eo_obj, &ev2.canvas.x, &ev2.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id); } } if (e->delete_me) break; } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); _evas_object_event_new(); - + event_id2 = _evas_event_counter; if (copy) copy = eina_list_free(copy); /* go thru our current list of ins */ - EINA_LIST_FOREACH(newin, l, obj) + EINA_LIST_FOREACH(newin, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev3.canvas.x = e->pointer.x; ev3.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev3.canvas.x, &ev3.canvas.y); - _evas_event_havemap_adjust(obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev3.canvas.x, &ev3.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed); /* if its not in the old list of ins send an enter event */ - if (!eina_list_data_find(e->pointer.object.in, obj)) + if (!eina_list_data_find(e->pointer.object.in, eo_obj)) { if (!obj->mouse_in) { obj->mouse_in = 1; - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2); } } if (e->delete_me) break; @@ -1073,27 +1201,38 @@ nogrep: /* and set up the new one */ e->pointer.object.in = newin; - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } _evas_unwalk(e); } EAPI void -evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data) +evas_event_feed_mouse_in(Evas *eo_e, unsigned int timestamp, const void *data) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + + eo_do(eo_e, evas_canvas_event_feed_mouse_in(timestamp, data)); +} + +void +_canvas_event_feed_mouse_in(Eo *eo_e, void *_pd, va_list *list) +{ + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; Eina_List *ins; Eina_List *l; Evas_Event_Mouse_In ev; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); e->pointer.inside = 1; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; if (e->pointer.mouse_grabbed != 0) return; @@ -1111,25 +1250,26 @@ evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data) ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); /* get new list of ins */ - ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y); - EINA_LIST_FOREACH(ins, l, obj) + ins = evas_event_objects_event_list(eo_e, NULL, e->pointer.x, e->pointer.y); + EINA_LIST_FOREACH(ins, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); - if (!eina_list_data_find(e->pointer.object.in, obj)) + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + if (!eina_list_data_find(e->pointer.object.in, eo_obj)) { if (!obj->mouse_in) { obj->mouse_in = 1; - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, &ev, event_id); } } if (e->delete_me) break; @@ -1138,24 +1278,35 @@ evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data) e->pointer.object.in = eina_list_free(e->pointer.object.in); /* and set up the new one */ e->pointer.object.in = ins; - _evas_post_event_callback_call(e); - evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data); + _evas_post_event_callback_call(eo_e, e); + evas_event_feed_mouse_move(eo_e, e->pointer.x, e->pointer.y, timestamp, data); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data) +evas_event_feed_mouse_out(Evas *eo_e, unsigned int timestamp, const void *data) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + + eo_do(eo_e, evas_canvas_event_feed_mouse_out(timestamp, data)); +} + +void +_canvas_event_feed_mouse_out(Eo *eo_e, void *_pd, va_list *list) +{ + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; Evas_Event_Mouse_Out ev; int event_id = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); e->pointer.inside = 0; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_object_event_new(); @@ -1171,7 +1322,7 @@ evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data) ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); @@ -1179,22 +1330,23 @@ evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data) { /* go thru old list of in objects */ Eina_List *l, *copy; - Evas_Object *obj; + Evas_Object *eo_obj; copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = e->pointer.x; ev.canvas.y = e->pointer.y; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); if (obj->mouse_in) { obj->mouse_in = 0; if (!obj->delete_me) { - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id); } obj->mouse_grabbed = 0; } @@ -1204,14 +1356,14 @@ evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data) /* free our old list of ins */ e->pointer.object.in = eina_list_free(e->pointer.object.in); e->pointer.mouse_grabbed = 0; - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); } if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_multi_down(Evas *e, +evas_event_feed_multi_down(Evas *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, @@ -1219,18 +1371,39 @@ evas_event_feed_multi_down(Evas *e, Evas_Button_Flags flags, unsigned int timestamp, const void *data) { - Eina_List *l, *copy; - Evas_Event_Multi_Down ev; - Evas_Object *obj; - int addgrab = 0; - int event_id = 0; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_feed_multi_down(d, x, y, rad, radx, rady, pres, ang, fx, fy, flags, timestamp, data)); +} + +void +_canvas_event_feed_multi_down(Eo *eo_e, void *_pd, va_list *list) +{ + int d = va_arg(*list, int); + int x = va_arg(*list, int); + int y = va_arg(*list, int); + double rad = va_arg(*list, double); + double radx = va_arg(*list, double); + double rady = va_arg(*list, double); + double pres = va_arg(*list, double); + double ang = va_arg(*list, double); + double fx = va_arg(*list, double); + double fy = va_arg(*list, double); + Evas_Button_Flags flags = va_arg(*list, Evas_Button_Flags); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; + Eina_List *l, *copy; + Evas_Event_Multi_Down ev; + Evas_Object *eo_obj; + int addgrab = 0; + int event_id = 0; + e->pointer.downs++; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_object_event_new(); @@ -1254,51 +1427,53 @@ evas_event_feed_multi_down(Evas *e, ev.flags = flags; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); /* append new touch point to the touch point list */ - _evas_touch_point_append(e, d, x, y); + _evas_touch_point_append(eo_e, d, x, y); if (e->pointer.mouse_grabbed == 0) { if (e->pointer.downs > 1) addgrab = e->pointer.downs - 1; } copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB) { obj->mouse_grabbed += addgrab + 1; e->pointer.mouse_grabbed += addgrab + 1; } } - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = x; ev.canvas.y = y; ev.canvas.xsub = fx; ev.canvas.ysub = fy; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); if (x != ev.canvas.x) ev.canvas.xsub = ev.canvas.x; // fixme - lost precision if (y != ev.canvas.y) ev.canvas.ysub = ev.canvas.y; // fixme - lost precision - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_DOWN, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_DOWN, &ev, event_id); if (e->delete_me) break; } if (copy) eina_list_free(copy); - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); /* update touch point's state to EVAS_TOUCH_POINT_STILL */ - _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_STILL); + _evas_touch_point_update(eo_e, d, x, y, EVAS_TOUCH_POINT_STILL); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_multi_up(Evas *e, +evas_event_feed_multi_up(Evas *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, @@ -1306,18 +1481,39 @@ evas_event_feed_multi_up(Evas *e, Evas_Button_Flags flags, unsigned int timestamp, const void *data) { - Eina_List *l, *copy; - Evas_Event_Multi_Up ev; - Evas_Object *obj; - int event_id = 0; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_feed_multi_up(d, x, y, rad, radx, rady, pres, ang, fx, fy, flags, timestamp, data)); +} + +void +_canvas_event_feed_multi_up(Eo *eo_e, void *_pd, va_list *list) +{ + int d = va_arg(*list, int); + int x = va_arg(*list, int); + int y = va_arg(*list, int); + double rad = va_arg(*list, double); + double radx = va_arg(*list, double); + double rady = va_arg(*list, double); + double pres = va_arg(*list, double); + double ang = va_arg(*list, double); + double fx = va_arg(*list, double); + double fy = va_arg(*list, double); + Evas_Button_Flags flags = va_arg(*list, Evas_Button_Flags); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; + Eina_List *l, *copy; + Evas_Event_Multi_Up ev; + Evas_Object *eo_obj; + int event_id = 0; + if (e->pointer.downs <= 0) return; e->pointer.downs--; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_object_event_new(); @@ -1341,21 +1537,22 @@ evas_event_feed_multi_up(Evas *e, ev.flags = flags; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); /* update released touch point */ - _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_UP); + _evas_touch_point_update(eo_e, d, x, y, EVAS_TOUCH_POINT_UP); copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ev.canvas.x = x; ev.canvas.y = y; ev.canvas.xsub = fx; ev.canvas.ysub = fy; - _evas_event_framespace_adjust(obj, &ev.canvas.x, &ev.canvas.y); - _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.canvas.x, &ev.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed); if (x != ev.canvas.x) ev.canvas.xsub = ev.canvas.x; // fixme - lost precision if (y != ev.canvas.y) @@ -1366,46 +1563,67 @@ evas_event_feed_multi_up(Evas *e, obj->mouse_grabbed--; e->pointer.mouse_grabbed--; } - if (e->events_frozen <= 0) - evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_UP, &ev, event_id); + if (!e->is_frozen) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_UP, &ev, event_id); if (e->delete_me) break; } if (copy) copy = eina_list_free(copy); - if ((e->pointer.mouse_grabbed == 0) && !_post_up_handle(e, timestamp, data)) - _evas_post_event_callback_call(e); + if ((e->pointer.mouse_grabbed == 0) && !_post_up_handle(eo_e, timestamp, data)) + _evas_post_event_callback_call(eo_e, e); /* remove released touch point from the touch point list */ - _evas_touch_point_remove(e, d); + _evas_touch_point_remove(eo_e, d); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_multi_move(Evas *e, +evas_event_feed_multi_move(Evas *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, unsigned int timestamp, const void *data) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - if (e->events_frozen > 0) return; + eo_do(eo_e, evas_canvas_event_feed_multi_move(d, x, y, rad, radx, rady, pres, ang, fx, fy, timestamp, data)); +} + +void +_canvas_event_feed_multi_move(Eo *eo_e, void *_pd, va_list *list) +{ + int d = va_arg(*list, int); + int x = va_arg(*list, int); + int y = va_arg(*list, int); + double rad = va_arg(*list, double); + double radx = va_arg(*list, double); + double rady = va_arg(*list, double); + double pres = va_arg(*list, double); + double ang = va_arg(*list, double); + double fx = va_arg(*list, double); + double fy = va_arg(*list, double); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; + + if (e->is_frozen) return; e->last_timestamp = timestamp; if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return; _evas_walk(e); /* update moved touch point */ - _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_MOVE); + _evas_touch_point_update(eo_e, d, x, y, EVAS_TOUCH_POINT_MOVE); /* if our mouse button is grabbed to any objects */ if (e->pointer.mouse_grabbed > 0) { /* go thru old list of in objects */ Eina_List *l, *copy; Evas_Event_Multi_Move ev; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0; _evas_object_event_new(); @@ -1428,33 +1646,34 @@ evas_event_feed_multi_move(Evas *e, ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { - if ((e->events_frozen <= 0) && - (evas_object_clippers_is_visible(obj) || obj->mouse_grabbed) && - (!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj)) && + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if ((!e->is_frozen) && + (evas_object_clippers_is_visible(eo_obj, obj) || obj->mouse_grabbed) && + (!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj)) && (!obj->clip.clipees)) { ev.cur.canvas.x = x; ev.cur.canvas.y = y; ev.cur.canvas.xsub = fx; ev.cur.canvas.ysub = fy; - _evas_event_framespace_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y); - _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.cur.canvas.x, &ev.cur.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); if (x != ev.cur.canvas.x) ev.cur.canvas.xsub = ev.cur.canvas.x; // fixme - lost precision if (y != ev.cur.canvas.y) ev.cur.canvas.ysub = ev.cur.canvas.y; // fixme - lost precision - evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id); } if (e->delete_me) break; } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } else @@ -1462,7 +1681,7 @@ evas_event_feed_multi_move(Evas *e, Eina_List *ins; Eina_List *l, *copy; Evas_Event_Multi_Move ev; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0; _evas_object_event_new(); @@ -1485,41 +1704,42 @@ evas_event_feed_multi_move(Evas *e, ev.locks = &(e->locks); ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); /* get all new in objects */ - ins = evas_event_objects_event_list(e, NULL, x, y); + ins = evas_event_objects_event_list(eo_e, NULL, x, y); /* go thru old list of in objects */ copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* if its under the pointer and its visible and its in the new */ /* in list */ // FIXME: i don't think we need this - // evas_object_clip_recalc(obj); - if ((e->events_frozen <= 0) && - evas_object_is_in_output_rect(obj, x, y, 1, 1) && - (evas_object_clippers_is_visible(obj) || + // evas_object_clip_recalc(eo_obj); + if ((!e->is_frozen) && + evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1) && + (evas_object_clippers_is_visible(eo_obj, obj) || obj->mouse_grabbed) && - eina_list_data_find(ins, obj) && - (!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj)) && + eina_list_data_find(ins, eo_obj) && + (!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj)) && (!obj->clip.clipees) && - ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y)) + ((!obj->precise_is_inside) || evas_object_is_inside(eo_obj, obj, x, y)) ) { ev.cur.canvas.x = x; ev.cur.canvas.y = y; ev.cur.canvas.xsub = fx; ev.cur.canvas.ysub = fy; - _evas_event_framespace_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y); - _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); + _evas_event_framespace_adjust(eo_obj, &ev.cur.canvas.x, &ev.cur.canvas.y); + _evas_event_havemap_adjust(eo_obj, obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed); if (x != ev.cur.canvas.x) ev.cur.canvas.xsub = ev.cur.canvas.x; // fixme - lost precision if (y != ev.cur.canvas.y) ev.cur.canvas.ysub = ev.cur.canvas.y; // fixme - lost precision - evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id); } if (e->delete_me) break; } @@ -1536,22 +1756,36 @@ evas_event_feed_multi_move(Evas *e, /* free our cur ins */ eina_list_free(ins); } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); } _evas_unwalk(e); } EAPI void -evas_event_feed_key_down(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data) +evas_event_feed_key_down(Evas *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data) { - int event_id = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_feed_key_down(keyname, key, string, compose, timestamp, data)); +} + +void +_canvas_event_feed_key_down(Eo *eo_e, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + const char *key = va_arg(*list, const char *); + const char *string = va_arg(*list, const char *); + const char *compose = va_arg(*list, const char *); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + int event_id = 0; + Evas_Public_Data *e = _pd; if (!keyname) return; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_walk(e); @@ -1571,7 +1805,7 @@ evas_event_feed_key_down(Evas *e, const char *keyname, const char *key, const ch ev.compose = compose; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); if (e->grabs) @@ -1594,9 +1828,10 @@ evas_event_feed_key_down(Evas *e, const char *keyname, const char *key, const ch { if (!(e->modifiers.mask & g->not_modifiers)) { - if (e->events_frozen <= 0 && - !evas_event_freezes_through(g->object)) - evas_object_event_callback_call(g->object, + Evas_Object_Protected_Data *object_obj = eo_data_get(g->object, EVAS_OBJ_CLASS); + if (!e->is_frozen && + !evas_event_freezes_through(g->object, object_obj)) + evas_object_event_callback_call(g->object, object_obj, EVAS_CALLBACK_KEY_DOWN, &ev, event_id); if (g->exclusive) exclusive = EINA_TRUE; @@ -1615,32 +1850,50 @@ evas_event_feed_key_down(Evas *e, const char *keyname, const char *key, const ch g = eina_list_data_get(l); l = eina_list_next(l); if (g->delete_me) - evas_key_grab_free(g->object, g->keyname, g->modifiers, - g->not_modifiers); + { + Evas_Object_Protected_Data *g_object_obj = eo_data_get(g->object, EVAS_OBJ_CLASS); + evas_key_grab_free(g->object, g_object_obj, g->keyname, + g->modifiers, g->not_modifiers); + } } } } } if ((e->focused) && (!exclusive)) { - if (e->events_frozen <= 0 && !evas_event_freezes_through(e->focused)) - evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_DOWN, + Evas_Object_Protected_Data *focused_obj = eo_data_get(e->focused, EVAS_OBJ_CLASS); + if (!e->is_frozen && !evas_event_freezes_through(e->focused, focused_obj)) + evas_object_event_callback_call(e->focused, focused_obj, EVAS_CALLBACK_KEY_DOWN, &ev, event_id); } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_key_up(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data) +evas_event_feed_key_up(Evas *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data) { - int event_id = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_event_feed_key_up(keyname, key, string, compose, timestamp, data)); +} + +void +_canvas_event_feed_key_up(Eo *eo_e, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + const char *key = va_arg(*list, const char *); + const char *string = va_arg(*list, const char *); + const char *compose = va_arg(*list, const char *); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + int event_id = 0; + Evas_Public_Data *e = _pd; if (!keyname) return; - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_walk(e); @@ -1660,7 +1913,7 @@ evas_event_feed_key_up(Evas *e, const char *keyname, const char *key, const char ev.compose = compose; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); if (e->grabs) @@ -1683,9 +1936,10 @@ evas_event_feed_key_up(Evas *e, const char *keyname, const char *key, const char (g->not_modifiers == ~e->modifiers.mask))) && (!strcmp(keyname, g->keyname))) { - if (e->events_frozen <= 0 && - !evas_event_freezes_through(g->object)) - evas_object_event_callback_call(g->object, + Evas_Object_Protected_Data *object_obj = eo_data_get(g->object, EVAS_OBJ_CLASS); + if (!e->is_frozen && + !evas_event_freezes_through(g->object, object_obj)) + evas_object_event_callback_call(g->object, object_obj, EVAS_CALLBACK_KEY_UP, &ev, event_id); if (g->exclusive) exclusive = EINA_TRUE; } @@ -1703,36 +1957,48 @@ evas_event_feed_key_up(Evas *e, const char *keyname, const char *key, const char EINA_LIST_FOREACH_SAFE(e->grabs, ll, l_next, gr) { if (gr->delete_me) - evas_key_grab_free(gr->object, gr->keyname, + { + Evas_Object_Protected_Data *gr_object_obj = + eo_data_get(gr->object, EVAS_OBJ_CLASS); + evas_key_grab_free(gr->object, gr_object_obj, gr->keyname, gr->modifiers, gr->not_modifiers); + } } } } } if ((e->focused) && (!exclusive)) { - if (e->events_frozen <= 0 && !evas_event_freezes_through(e->focused)) - evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_UP, + Evas_Object_Protected_Data *focused_obj = eo_data_get(e->focused, EVAS_OBJ_CLASS); + if (!e->is_frozen && !evas_event_freezes_through(e->focused, focused_obj)) + evas_object_event_callback_call(e->focused, focused_obj, EVAS_CALLBACK_KEY_UP, &ev, event_id); } - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); } EAPI void -evas_event_feed_hold(Evas *e, int hold, unsigned int timestamp, const void *data) +evas_event_feed_hold(Evas *eo_e, int hold, unsigned int timestamp, const void *data) { + eo_do(eo_e, evas_canvas_event_feed_hold(hold, timestamp, data)); +} + +void +_canvas_event_feed_hold(Eo *eo_e, void *_pd, va_list *list) +{ + int hold = va_arg(*list, int); + unsigned int timestamp = va_arg(*list, unsigned int); + const void *data = va_arg(*list, const void *); + + Evas_Public_Data *e = _pd; Eina_List *l, *copy; Evas_Event_Hold ev; - Evas_Object *obj; + Evas_Object *eo_obj; int event_id = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); - - if (e->events_frozen > 0) return; + if (e->is_frozen) return; e->last_timestamp = timestamp; _evas_object_event_new(); @@ -1742,64 +2008,90 @@ evas_event_feed_hold(Evas *e, int hold, unsigned int timestamp, const void *data ev.data = (void *)data; ev.timestamp = timestamp; ev.event_flags = e->default_event_flags; - ev.dev = _evas_device_top_get(e); + ev.dev = _evas_device_top_get(eo_e); if (ev.dev) _evas_device_ref(ev.dev); _evas_walk(e); copy = evas_event_list_copy(e->pointer.object.in); - EINA_LIST_FOREACH(copy, l, obj) + EINA_LIST_FOREACH(copy, l, eo_obj) { - if ((e->events_frozen <= 0) && !evas_event_freezes_through(obj)) - evas_object_event_callback_call(obj, EVAS_CALLBACK_HOLD, &ev, event_id); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if ((!e->is_frozen) && !evas_event_freezes_through(eo_obj, obj)) + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_HOLD, &ev, event_id); if (e->delete_me) break; } if (copy) copy = eina_list_free(copy); - _evas_post_event_callback_call(e); + _evas_post_event_callback_call(eo_e, e); if (ev.dev) _evas_device_unref(ev.dev); _evas_unwalk(e); _evas_object_event_new(); } EAPI void -evas_object_freeze_events_set(Evas_Object *obj, Eina_Bool freeze) +evas_object_freeze_events_set(Evas_Object *eo_obj, Eina_Bool freeze) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_freeze_events_set(freeze)); +} +void +_freeze_events_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool freeze = va_arg(*list, int); + Evas_Object_Protected_Data *obj = _pd; freeze = !!freeze; if (obj->freeze_events == freeze) return; obj->freeze_events = freeze; - evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE); + evas_object_smart_member_cache_invalidate(eo_obj, EINA_FALSE, EINA_TRUE); } EAPI Eina_Bool -evas_object_freeze_events_get(const Evas_Object *obj) +evas_object_freeze_events_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - return obj->freeze_events; + Eina_Bool freeze_events = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_freeze_events_get(&freeze_events)); + return freeze_events; +} + +void +_freeze_events_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *freeze_events = va_arg(*list, Eina_Bool *); + const Evas_Object_Protected_Data *obj = _pd; + if (freeze_events) *freeze_events = obj->freeze_events; } EAPI void -evas_object_pass_events_set(Evas_Object *obj, Eina_Bool pass) +evas_object_pass_events_set(Evas_Object *eo_obj, Eina_Bool pass) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_pass_events_set(pass)); +} + +void +_pass_events_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool pass = va_arg(*list, int); + Evas_Object_Protected_Data *obj = _pd; pass = !!pass; if (obj->pass_events == pass) return; obj->pass_events = pass; - evas_object_smart_member_cache_invalidate(obj, EINA_TRUE, EINA_FALSE); - if (evas_object_is_in_output_rect(obj, + evas_object_smart_member_cache_invalidate(eo_obj, EINA_TRUE, EINA_FALSE); + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && ((!obj->precise_is_inside) || - (evas_object_is_inside(obj, + (evas_object_is_inside(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y)))) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -1807,31 +2099,49 @@ evas_object_pass_events_set(Evas_Object *obj, Eina_Bool pass) } EAPI Eina_Bool -evas_object_pass_events_get(const Evas_Object *obj) +evas_object_pass_events_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - return obj->pass_events; + Eina_Bool pass_events = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_pass_events_get(&pass_events)); + return pass_events; +} + +void +_pass_events_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *pass_events = va_arg(*list, Eina_Bool *); + const Evas_Object_Protected_Data *obj = _pd; + if (pass_events) *pass_events = obj->pass_events; } EAPI void -evas_object_repeat_events_set(Evas_Object *obj, Eina_Bool repeat) +evas_object_repeat_events_set(Evas_Object *eo_obj, Eina_Bool repeat) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_repeat_events_set(repeat)); +} + +void +_repeat_events_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool repeat = va_arg(*list, int); + Evas_Object_Protected_Data *obj = _pd; repeat = !!repeat; if (obj->repeat_events == repeat) return; obj->repeat_events = repeat; - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && ((!obj->precise_is_inside) || - (evas_object_is_inside(obj, + (evas_object_is_inside(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y)))) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -1839,53 +2149,108 @@ evas_object_repeat_events_set(Evas_Object *obj, Eina_Bool repeat) } EAPI Eina_Bool -evas_object_repeat_events_get(const Evas_Object *obj) +evas_object_repeat_events_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - return obj->repeat_events; + Eina_Bool repeat_events = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_repeat_events_get(&repeat_events)); + return repeat_events; +} + +void +_repeat_events_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *repeat_events = va_arg(*list, Eina_Bool *); + const Evas_Object_Protected_Data *obj = _pd; + if (repeat_events) *repeat_events = obj->repeat_events; } EAPI void -evas_object_propagate_events_set(Evas_Object *obj, Eina_Bool prop) +evas_object_propagate_events_set(Evas_Object *eo_obj, Eina_Bool prop) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_propagate_events_set(prop)); +} + +void +_propagate_events_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool prop = va_arg(*list, int); + Evas_Object_Protected_Data *obj = _pd; obj->no_propagate = !prop; } EAPI Eina_Bool -evas_object_propagate_events_get(const Evas_Object *obj) +evas_object_propagate_events_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - return !(obj->no_propagate); + Eina_Bool no_propagate = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_propagate_events_get(&no_propagate)); + return no_propagate; +} + +void +_propagate_events_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *no_propagate = va_arg(*list, Eina_Bool *); + const Evas_Object_Protected_Data *obj = _pd; + if (no_propagate) *no_propagate = !(obj->no_propagate); } EAPI void -evas_object_pointer_mode_set(Evas_Object *obj, Evas_Object_Pointer_Mode setting) +evas_object_pointer_mode_set(Evas_Object *eo_obj, Evas_Object_Pointer_Mode setting) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_pointer_mode_set(setting)); +} + +void +_pointer_mode_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Pointer_Mode setting = va_arg(*list, Evas_Object_Pointer_Mode); + Evas_Object_Protected_Data *obj = _pd; obj->pointer_mode = setting; } EAPI Evas_Object_Pointer_Mode -evas_object_pointer_mode_get(const Evas_Object *obj) +evas_object_pointer_mode_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EVAS_OBJECT_POINTER_MODE_AUTOGRAB; MAGIC_CHECK_END(); - return obj->pointer_mode; + Evas_Object_Pointer_Mode setting = EVAS_OBJECT_POINTER_MODE_AUTOGRAB; + eo_do((Eo *)eo_obj, evas_obj_pointer_mode_get(&setting)); + return setting; +} + +void +_pointer_mode_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Pointer_Mode *setting = va_arg(*list, Evas_Object_Pointer_Mode *); + const Evas_Object_Protected_Data *obj = _pd; + if (setting) *setting = obj->pointer_mode; } EAPI void -evas_event_refeed_event(Evas *e, void *event_copy, Evas_Callback_Type event_type) +evas_event_refeed_event(Evas *eo_e, void *event_copy, Evas_Callback_Type event_type) { + eo_do(eo_e, evas_canvas_event_refeed_event(event_copy, event_type)); +} + +void +_canvas_event_refeed_event(Eo *eo_e, void *_pd EINA_UNUSED, va_list *list) +{ + void *event_copy = va_arg(*list, void *); + Evas_Callback_Type event_type = va_arg(*list, Evas_Callback_Type); + if (!event_copy) return; switch (event_type) @@ -1893,67 +2258,67 @@ evas_event_refeed_event(Evas *e, void *event_copy, Evas_Callback_Type event_type case EVAS_CALLBACK_MOUSE_IN: { Evas_Event_Mouse_In *ev = event_copy; - evas_event_feed_mouse_in(e, ev->timestamp, ev->data); + evas_event_feed_mouse_in(eo_e, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_MOUSE_OUT: { Evas_Event_Mouse_Out *ev = event_copy; - evas_event_feed_mouse_out(e, ev->timestamp, ev->data); + evas_event_feed_mouse_out(eo_e, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_MOUSE_DOWN: { Evas_Event_Mouse_Down *ev = event_copy; - evas_event_feed_mouse_down(e, ev->button, ev->flags, ev-> timestamp, ev->data); + evas_event_feed_mouse_down(eo_e, ev->button, ev->flags, ev-> timestamp, ev->data); break; } case EVAS_CALLBACK_MOUSE_UP: { Evas_Event_Mouse_Up *ev = event_copy; - evas_event_feed_mouse_up(e, ev->button, ev->flags, ev-> timestamp, ev->data); + evas_event_feed_mouse_up(eo_e, ev->button, ev->flags, ev-> timestamp, ev->data); break; } case EVAS_CALLBACK_MOUSE_MOVE: { Evas_Event_Mouse_Move *ev = event_copy; - evas_event_feed_mouse_move(e, ev->cur.canvas.x, ev->cur.canvas.y, ev->timestamp, ev->data); + evas_event_feed_mouse_move(eo_e, ev->cur.canvas.x, ev->cur.canvas.y, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_MOUSE_WHEEL: { Evas_Event_Mouse_Wheel *ev = event_copy; - evas_event_feed_mouse_wheel(e, ev->direction, ev-> z, ev->timestamp, ev->data); + evas_event_feed_mouse_wheel(eo_e, ev->direction, ev-> z, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_MULTI_DOWN: { Evas_Event_Multi_Down *ev = event_copy; - evas_event_feed_multi_down(e, ev->device, ev->canvas.x, ev->canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->canvas.xsub, ev->canvas.ysub, ev->flags, ev->timestamp, ev->data); + evas_event_feed_multi_down(eo_e, ev->device, ev->canvas.x, ev->canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->canvas.xsub, ev->canvas.ysub, ev->flags, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_MULTI_UP: { Evas_Event_Multi_Up *ev = event_copy; - evas_event_feed_multi_up(e, ev->device, ev->canvas.x, ev->canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->canvas.xsub, ev->canvas.ysub, ev->flags, ev->timestamp, ev->data); + evas_event_feed_multi_up(eo_e, ev->device, ev->canvas.x, ev->canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->canvas.xsub, ev->canvas.ysub, ev->flags, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_MULTI_MOVE: { Evas_Event_Multi_Move *ev = event_copy; - evas_event_feed_multi_move(e, ev->device, ev->cur.canvas.x, ev->cur.canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->cur.canvas.xsub, ev->cur.canvas.ysub, ev->timestamp, ev->data); + evas_event_feed_multi_move(eo_e, ev->device, ev->cur.canvas.x, ev->cur.canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->cur.canvas.xsub, ev->cur.canvas.ysub, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_KEY_DOWN: { Evas_Event_Key_Down *ev = event_copy; - evas_event_feed_key_down(e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data); + evas_event_feed_key_down(eo_e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data); break; } case EVAS_CALLBACK_KEY_UP: { Evas_Event_Key_Up *ev = event_copy; - evas_event_feed_key_up(e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data); + evas_event_feed_key_up(eo_e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data); break; } default: /* All non-input events are not handeled */ @@ -1962,10 +2327,20 @@ evas_event_refeed_event(Evas *e, void *event_copy, Evas_Callback_Type event_type } EAPI int -evas_event_down_count_get(const Evas *e) +evas_event_down_count_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return e->pointer.downs; + int ret = 0; + eo_do((Eo *)eo_e, evas_canvas_event_down_count_get(&ret)); + return ret; +} + +void +_canvas_event_down_count_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *ret = va_arg(*list, int *); + const Evas_Public_Data *e = _pd; + *ret = e->pointer.downs; } diff --git a/legacy/evas/src/lib/canvas/evas_focus.c b/legacy/evas/src/lib/canvas/evas_focus.c index 29da7e7140..0e1914d78a 100644 --- a/legacy/evas/src/lib/canvas/evas_focus.c +++ b/legacy/evas/src/lib/canvas/evas_focus.c @@ -8,12 +8,21 @@ /* public calls */ EAPI void -evas_object_focus_set(Evas_Object *obj, Eina_Bool focus) +evas_object_focus_set(Evas_Object *eo_obj, Eina_Bool focus) { + eo_do(eo_obj, evas_obj_focus_set(focus)); +} + +void +_focus_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool focus = va_arg(*list, int); + int event_id = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = _pd; _evas_object_event_new(); @@ -24,31 +33,42 @@ evas_object_focus_set(Evas_Object *obj, Eina_Bool focus) if (obj->layer->evas->focused) evas_object_focus_set(obj->layer->evas->focused, 0); obj->focused = 1; - obj->layer->evas->focused = obj; - evas_object_event_callback_call(obj, EVAS_CALLBACK_FOCUS_IN, NULL, event_id); - evas_event_callback_call(obj->layer->evas, - EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN, obj); + obj->layer->evas->focused = eo_obj; + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_FOCUS_IN, NULL, event_id); + evas_event_callback_call(obj->layer->evas->evas, + EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN, eo_obj); } else { if (!obj->focused) goto end; obj->focused = 0; obj->layer->evas->focused = NULL; - evas_object_event_callback_call(obj, EVAS_CALLBACK_FOCUS_OUT, NULL, event_id); - evas_event_callback_call(obj->layer->evas, - EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT, obj); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_FOCUS_OUT, NULL, event_id); + evas_event_callback_call(obj->layer->evas->evas, + EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT, eo_obj); } end: - _evas_post_event_callback_call(obj->layer->evas); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } EAPI Eina_Bool -evas_object_focus_get(const Evas_Object *obj) +evas_object_focus_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - return obj->focused; + Eina_Bool focus = 0; + eo_do((Eo *)eo_obj, evas_obj_focus_get(&focus)); + return focus; +} + +void +_focus_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *focus = va_arg(*list, Eina_Bool *); + + const Evas_Object_Protected_Data *obj = _pd; + *focus = obj->focused; } EAPI Evas_Object * @@ -57,5 +77,16 @@ evas_focus_get(const Evas *e) MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - return e->focused; + Evas_Object *ret = NULL; + eo_do((Eo *)e, evas_canvas_focus_get(&ret)); + return ret; } + +void +_canvas_focus_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object **ret = va_arg(*list, Evas_Object **); + const Evas_Public_Data *e = _pd; + *ret = e->focused; +} + diff --git a/legacy/evas/src/lib/canvas/evas_font_dir.c b/legacy/evas/src/lib/canvas/evas_font_dir.c index 94ffd4ad6b..e67668513b 100644 --- a/legacy/evas/src/lib/canvas/evas_font_dir.c +++ b/legacy/evas/src/lib/canvas/evas_font_dir.c @@ -135,9 +135,10 @@ evas_font_set_get(const char *name) } void -evas_fonts_zero_free(Evas *evas) +evas_fonts_zero_free(Evas *eo_evas) { Fndat *fd; + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); EINA_LIST_FREE(fonts_zero, fd) { @@ -153,9 +154,10 @@ evas_fonts_zero_free(Evas *evas) } void -evas_fonts_zero_presure(Evas *evas) +evas_fonts_zero_presure(Evas *eo_evas) { Fndat *fd; + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); while (fonts_zero && eina_list_count(fonts_zero) > 4) /* 4 is arbitrary */ @@ -179,10 +181,11 @@ evas_fonts_zero_presure(Evas *evas) } void -evas_font_free(Evas *evas, void *font) +evas_font_free(Evas *eo_evas, void *font) { Eina_List *l; Fndat *fd; + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); EINA_LIST_FOREACH(fonts_cache, l, fd) { @@ -236,9 +239,10 @@ evas_font_init(void) #ifdef HAVE_FONTCONFIG static Evas_Font_Set * -evas_load_fontconfig(Evas *evas, FcFontSet *set, int size, +evas_load_fontconfig(Evas *eo_evas, FcFontSet *set, int size, Font_Rend_Flags wanted_rend) { + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); Evas_Font_Set *font = NULL; int i; @@ -494,8 +498,9 @@ evas_font_name_parse(Evas_Font_Description *fdesc, const char *name) } void * -evas_font_load(Evas *evas, Evas_Font_Description *fdesc, const char *source, Evas_Font_Size size) +evas_font_load(Evas *eo_evas, Evas_Font_Description *fdesc, const char *source, Evas_Font_Size size) { + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); #ifdef HAVE_FONTCONFIG FcPattern *p_nm = NULL; FcFontSet *set = NULL; @@ -545,7 +550,7 @@ evas_font_load(Evas *evas, Evas_Font_Description *fdesc, const char *source, Eva #ifdef HAVE_FONTCONFIG if (found_fd) { - font = evas_load_fontconfig(evas, found_fd->set, size, wanted_rend); + font = evas_load_fontconfig(evas->evas, found_fd->set, size, wanted_rend); goto on_find; } #endif @@ -578,7 +583,7 @@ evas_font_load(Evas *evas, Evas_Font_Description *fdesc, const char *source, Eva #ifdef HAVE_FONTCONFIG if (found_fd) { - font = evas_load_fontconfig(evas, found_fd->set, size, wanted_rend); + font = evas_load_fontconfig(evas->evas, found_fd->set, size, wanted_rend); goto on_find; } #endif @@ -765,7 +770,7 @@ evas_font_load(Evas *evas, Evas_Font_Description *fdesc, const char *source, Eva } else { - font = evas_load_fontconfig(evas, set, size, wanted_rend); + font = evas_load_fontconfig(evas->evas, set, size, wanted_rend); } } #endif @@ -796,15 +801,17 @@ evas_font_load(Evas *evas, Evas_Font_Description *fdesc, const char *source, Eva } void -evas_font_load_hinting_set(Evas *evas, void *font, int hinting) +evas_font_load_hinting_set(Evas *eo_evas, void *font, int hinting) { + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); evas->engine.func->font_hinting_set(evas->engine.data.output, font, hinting); } Eina_List * -evas_font_dir_available_list(const Evas *evas) +evas_font_dir_available_list(const Evas *eo_evas) { + const Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); Eina_List *l; Eina_List *ll; Eina_List *available = NULL; @@ -1217,152 +1224,243 @@ evas_object_text_font_string_parse(char *buffer, char dest[14][256]) } EAPI void -evas_font_path_clear(Evas *e) +evas_font_path_clear(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); - while (e->font_path) + eo_do(eo_e, evas_canvas_font_path_clear()); +} + +void +_canvas_font_path_clear(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *evas = _pd; + while (evas->font_path) { - eina_stringshare_del(e->font_path->data); - e->font_path = eina_list_remove(e->font_path, e->font_path->data); + eina_stringshare_del(evas->font_path->data); + evas->font_path = eina_list_remove(evas->font_path, evas->font_path->data); } } EAPI void -evas_font_path_append(Evas *e, const char *path) +evas_font_path_append(Evas *eo_e, const char *path) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_font_path_append(path)); +} +void +_canvas_font_path_append(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *path = va_arg(*list, const char *); + Evas_Public_Data *e = _pd; if (!path) return; e->font_path = eina_list_append(e->font_path, eina_stringshare_add(path)); } EAPI void -evas_font_path_prepend(Evas *e, const char *path) +evas_font_path_prepend(Evas *eo_e, const char *path) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_font_path_prepend(path)); +} +void +_canvas_font_path_prepend(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *path = va_arg(*list, const char *); + Evas_Public_Data *e = _pd; if (!path) return; e->font_path = eina_list_prepend(e->font_path, eina_stringshare_add(path)); } EAPI const Eina_List * -evas_font_path_list(const Evas *e) +evas_font_path_list(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - return e->font_path; + const Eina_List *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_font_path_list(&ret)); + return ret; } -static void -evas_font_object_rehint(Evas_Object *obj) +void +_canvas_font_path_list(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) { - if (obj->smart.smart) + const Eina_List **ret = va_arg(*list, const Eina_List **); + const Evas_Public_Data *e = _pd; + *ret = e->font_path; +} + +void +evas_font_object_rehint(Evas_Object *eo_obj) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (obj->is_smart) { - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), obj) - evas_font_object_rehint(obj); + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj) + evas_font_object_rehint(obj->object); } else { if (!strcmp(obj->type, "text")) - _evas_object_text_rehint(obj); + _evas_object_text_rehint(eo_obj); if (!strcmp(obj->type, "textblock")) - _evas_object_textblock_rehint(obj); + _evas_object_textblock_rehint(eo_obj); } } EAPI void -evas_font_hinting_set(Evas *e, Evas_Font_Hinting_Flags hinting) +evas_font_hinting_set(Evas *eo_e, Evas_Font_Hinting_Flags hinting) { - Evas_Layer *lay; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_font_hinting_set(hinting)); +} + +void +_canvas_font_hinting_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Font_Hinting_Flags hinting = va_arg(*list, Evas_Font_Hinting_Flags); + Evas_Layer *lay; + + Evas_Public_Data *e = _pd; if (e->hinting == hinting) return; e->hinting = hinting; EINA_INLIST_FOREACH(e->layers, lay) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_FOREACH(lay->objects, obj) - evas_font_object_rehint(obj); + evas_font_object_rehint(obj->object); } } EAPI Evas_Font_Hinting_Flags -evas_font_hinting_get(const Evas *e) +evas_font_hinting_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return EVAS_FONT_HINTING_BYTECODE; MAGIC_CHECK_END(); - return e->hinting; + Evas_Font_Hinting_Flags ret = EVAS_FONT_HINTING_BYTECODE; + eo_do((Eo *)eo_e, evas_canvas_font_hinting_get(&ret)); + return ret; +} + +void +_canvas_font_hinting_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Font_Hinting_Flags *ret = va_arg(*list, Evas_Font_Hinting_Flags *); + const Evas_Public_Data *e = _pd; + *ret = e->hinting; } EAPI Eina_Bool -evas_font_hinting_can_hint(const Evas *e, Evas_Font_Hinting_Flags hinting) +evas_font_hinting_can_hint(const Evas *eo_e, Evas_Font_Hinting_Flags hinting) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); + Eina_Bool ret = 0; + eo_do((Eo *)eo_e, evas_canvas_font_hinting_can_hint(hinting, &ret)); + return ret; +} + +void +_canvas_font_hinting_can_hint(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Font_Hinting_Flags hinting = va_arg(*list, Evas_Font_Hinting_Flags); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + const Evas_Public_Data *e = _pd; if (e->engine.func->font_hinting_can_hint) - return e->engine.func->font_hinting_can_hint(e->engine.data.output, + *ret = e->engine.func->font_hinting_can_hint(e->engine.data.output, hinting); - return EINA_FALSE; + else *ret = EINA_FALSE; } EAPI void -evas_font_cache_flush(Evas *e) +evas_font_cache_flush(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_font_cache_flush()); +} +void +_canvas_font_cache_flush(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; e->engine.func->font_cache_flush(e->engine.data.output); } EAPI void -evas_font_cache_set(Evas *e, int size) +evas_font_cache_set(Evas *eo_e, int size) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_font_cache_set(size)); +} +void +_canvas_font_cache_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int size = va_arg(*list, int); + Evas_Public_Data *e = _pd; if (size < 0) size = 0; e->engine.func->font_cache_set(e->engine.data.output, size); } EAPI int -evas_font_cache_get(const Evas *e) +evas_font_cache_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); + int ret = 0; + eo_do((Eo *)eo_e, evas_canvas_font_cache_get(&ret)); + return ret; +} - return e->engine.func->font_cache_get(e->engine.data.output); +void +_canvas_font_cache_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *ret = va_arg(*list, int *); + const Evas_Public_Data *e = _pd; + *ret = e->engine.func->font_cache_get(e->engine.data.output); } EAPI Eina_List * -evas_font_available_list(const Evas *e) +evas_font_available_list(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Eina_List *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_font_available_list(&ret)); + return ret; +} - return evas_font_dir_available_list(e); +void +_canvas_font_available_list(Eo *eo_e, void *_pd EINA_UNUSED, va_list *list) +{ + Eina_List **ret = va_arg(*list, Eina_List **); + *ret = evas_font_dir_available_list(eo_e); } EAPI void -evas_font_available_list_free(Evas *e, Eina_List *available) +evas_font_available_list_free(Evas *eo_e, Eina_List *available) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); diff --git a/legacy/evas/src/lib/canvas/evas_gl.c b/legacy/evas/src/lib/canvas/evas_gl.c index 58021dfc09..faf5280a8f 100644 --- a/legacy/evas/src/lib/canvas/evas_gl.c +++ b/legacy/evas/src/lib/canvas/evas_gl.c @@ -6,7 +6,7 @@ struct _Evas_GL { DATA32 magic; - Evas *evas; + Evas_Public_Data *evas; Eina_List *contexts; Eina_List *surfaces; @@ -35,7 +35,7 @@ evas_gl_new(Evas *e) if (!evas_gl) return NULL; evas_gl->magic = MAGIC_EVAS_GL; - evas_gl->evas = e; + evas_gl->evas = eo_data_get(e, EVAS_CLASS); if (!evas_gl->evas->engine.func->gl_context_create) { diff --git a/legacy/evas/src/lib/canvas/evas_key.c b/legacy/evas/src/lib/canvas/evas_key.c index f74ef3498f..aef0fc4dae 100644 --- a/legacy/evas/src/lib/canvas/evas_key.c +++ b/legacy/evas/src/lib/canvas/evas_key.c @@ -32,21 +32,41 @@ evas_key_lock_number(const Evas_Lock *l, const char *keyname) /* public calls */ EAPI const Evas_Modifier * -evas_key_modifier_get(const Evas *e) +evas_key_modifier_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - return &(e->modifiers); + const Evas_Modifier *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_key_modifier_get(&ret)); + return ret; +} + +void +_canvas_key_modifier_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Modifier **ret = va_arg(*list, const Evas_Modifier **); + const Evas_Public_Data *e = _pd; + *ret = &(e->modifiers); } EAPI const Evas_Lock * -evas_key_lock_get(const Evas *e) +evas_key_lock_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - return &(e->locks); + const Evas_Lock *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_key_lock_get(&ret)); + return ret; +} + +void +_canvas_key_lock_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Lock **ret = va_arg(*list, const Evas_Lock **); + const Evas_Public_Data *e = _pd; + *ret = &(e->locks); } EAPI Eina_Bool @@ -82,14 +102,23 @@ evas_key_lock_is_set(const Evas_Lock *l, const char *keyname) } EAPI void -evas_key_modifier_add(Evas *e, const char *keyname) +evas_key_modifier_add(Evas *eo_e, const char *keyname) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_modifier_add(keyname)); +} + +void +_canvas_key_modifier_add(Eo *eo_e, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + + Evas_Public_Data *e = _pd; if (!keyname) return; if (e->modifiers.mod.count >= 64) return; - evas_key_modifier_del(e, keyname); + evas_key_modifier_del(eo_e, keyname); e->modifiers.mod.count++; e->modifiers.mod.list = realloc(e->modifiers.mod.list, e->modifiers.mod.count * sizeof(char *)); e->modifiers.mod.list[e->modifiers.mod.count - 1] = strdup(keyname); @@ -97,13 +126,23 @@ evas_key_modifier_add(Evas *e, const char *keyname) } EAPI void -evas_key_modifier_del(Evas *e, const char *keyname) +evas_key_modifier_del(Evas *eo_e, const char *keyname) { - int i; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + if (!eo_e) return; + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_modifier_del(keyname)); +} + +void +_canvas_key_modifier_del(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + + Evas_Public_Data *e = _pd; + int i; + if (!keyname) return; for (i = 0; i < e->modifiers.mod.count; i++) { @@ -122,14 +161,23 @@ evas_key_modifier_del(Evas *e, const char *keyname) } EAPI void -evas_key_lock_add(Evas *e, const char *keyname) +evas_key_lock_add(Evas *eo_e, const char *keyname) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_lock_add(keyname)); +} + +void +_canvas_key_lock_add(Eo *eo_e, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + if (!keyname) return; + Evas_Public_Data *e = _pd; if (e->locks.lock.count >= 64) return; - evas_key_lock_del(e, keyname); + evas_key_lock_del(eo_e, keyname); e->locks.lock.count++; e->locks.lock.list = realloc(e->locks.lock.list, e->locks.lock.count * sizeof(char *)); e->locks.lock.list[e->locks.lock.count - 1] = strdup(keyname); @@ -137,13 +185,21 @@ evas_key_lock_add(Evas *e, const char *keyname) } EAPI void -evas_key_lock_del(Evas *e, const char *keyname) +evas_key_lock_del(Evas *eo_e, const char *keyname) { - int i; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_lock_del(keyname)); +} + +void +_canvas_key_lock_del(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + + int i; + Evas_Public_Data *e = _pd; if (!keyname) return; e->locks.mask = 0; for (i = 0; i < e->locks.lock.count; i++) @@ -163,14 +219,23 @@ evas_key_lock_del(Evas *e, const char *keyname) } EAPI void -evas_key_modifier_on(Evas *e, const char *keyname) +evas_key_modifier_on(Evas *eo_e, const char *keyname) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_modifier_on(keyname)); +} + +void +_canvas_key_modifier_on(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask num; int n; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); + Evas_Public_Data *e = _pd; n = (Evas_Modifier_Mask)evas_key_modifier_number(&(e->modifiers), keyname); if (n < 0) return; num = (Evas_Modifier_Mask)n; @@ -179,14 +244,23 @@ evas_key_modifier_on(Evas *e, const char *keyname) } EAPI void -evas_key_modifier_off(Evas *e, const char *keyname) +evas_key_modifier_off(Evas *eo_e, const char *keyname) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_modifier_off(keyname)); +} + +void +_canvas_key_modifier_off(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask num; int n; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); + Evas_Public_Data *e = _pd; n = evas_key_modifier_number(&(e->modifiers), keyname); if (n < 0) return; num = (Evas_Modifier_Mask)n; @@ -195,14 +269,23 @@ evas_key_modifier_off(Evas *e, const char *keyname) } EAPI void -evas_key_lock_on(Evas *e, const char *keyname) +evas_key_lock_on(Evas *eo_e, const char *keyname) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_lock_on(keyname)); +} + +void +_canvas_key_lock_on(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask num; int n; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); + Evas_Public_Data *e = _pd; n = evas_key_lock_number(&(e->locks), keyname); if (n < 0) return; num = (Evas_Modifier_Mask)n; @@ -211,14 +294,23 @@ evas_key_lock_on(Evas *e, const char *keyname) } EAPI void -evas_key_lock_off(Evas *e, const char *keyname) +evas_key_lock_off(Evas *eo_e, const char *keyname) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_key_lock_off(keyname)); +} + +void +_canvas_key_lock_off(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask num; int n; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); + Evas_Public_Data *e = _pd; n = evas_key_lock_number(&(e->locks), keyname); if (n < 0) return; num = (Evas_Modifier_Mask)n; @@ -229,17 +321,34 @@ evas_key_lock_off(Evas *e, const char *keyname) /* errr need to add key grabbing/ungrabbing calls - missing modifier stuff. */ EAPI Evas_Modifier_Mask -evas_key_modifier_mask_get(const Evas *e, const char *keyname) +evas_key_modifier_mask_get(const Evas *eo_e, const char *keyname) { - Evas_Modifier_Mask num; - int n; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - if (!keyname) return 0; - n = evas_key_modifier_number(&(e->modifiers), keyname); - if (n < 0) return 0; - num = (Evas_Modifier_Mask)n; - return 1 << num; + Evas_Modifier_Mask ret = 0; + eo_do((Eo *)eo_e, evas_canvas_key_modifier_mask_get(keyname, &ret)); + return ret; +} + +void +_canvas_key_modifier_mask_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask *ret = va_arg(*list, Evas_Modifier_Mask *); + + Evas_Modifier_Mask num; + int n; + *ret = 0; + + if (!keyname) return; + const Evas_Public_Data *e = _pd; + n = evas_key_modifier_number(&(e->modifiers), keyname); + if (n < 0) + { + *ret = 0; + return; + } + num = (Evas_Modifier_Mask)n; + *ret = 1 << num; } diff --git a/legacy/evas/src/lib/canvas/evas_key_grab.c b/legacy/evas/src/lib/canvas/evas_key_grab.c index 3fc2172f35..85e1761b31 100644 --- a/legacy/evas/src/lib/canvas/evas_key_grab.c +++ b/legacy/evas/src/lib/canvas/evas_key_grab.c @@ -7,18 +7,18 @@ /* Evas and then a linked lists of grabs for that key and what */ /* modifiers/not_modifers they use */ -static Evas_Key_Grab *evas_key_grab_new (Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive); -static Evas_Key_Grab *evas_key_grab_find (Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive); +static Evas_Key_Grab *evas_key_grab_new (Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive); +static Evas_Key_Grab *evas_key_grab_find (Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive); static Evas_Key_Grab * -evas_key_grab_new(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive) +evas_key_grab_new(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive) { /* MEM OK */ Evas_Key_Grab *g; g = evas_mem_calloc(sizeof(Evas_Key_Grab)); if (!g) return NULL; - g->object = obj; + g->object = eo_obj; g->modifiers = modifiers; g->not_modifiers = not_modifiers; g->exclusive = exclusive; @@ -39,12 +39,12 @@ evas_key_grab_new(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modi return NULL; } } - g->object->grabs = eina_list_append(g->object->grabs, g); + obj->grabs = eina_list_append(obj->grabs, g); if (eina_error_get()) { MERR_BAD(); evas_mem_free(sizeof(Eina_List)); - g->object->grabs = eina_list_append(g->object->grabs, g); + obj->grabs = eina_list_append(obj->grabs, g); if (eina_error_get()) { MERR_FATAL(); @@ -62,7 +62,7 @@ evas_key_grab_new(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modi if (eina_error_get()) { MERR_FATAL(); - g->object->grabs = eina_list_remove(g->object->grabs, g); + obj->grabs = eina_list_remove(obj->grabs, g); free(g->keyname); free(g); return NULL; @@ -72,7 +72,7 @@ evas_key_grab_new(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modi } static Evas_Key_Grab * -evas_key_grab_find(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive) +evas_key_grab_find(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive) { /* MEM OK */ Eina_List *l; @@ -84,7 +84,7 @@ evas_key_grab_find(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask mod (g->not_modifiers == not_modifiers) && (!strcmp(g->keyname, keyname))) { - if ((exclusive) || (obj == g->object)) return g; + if ((exclusive) || (eo_obj == g->object)) return g; } } return NULL; @@ -93,7 +93,7 @@ evas_key_grab_find(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask mod /* local calls */ void -evas_object_grabs_cleanup(Evas_Object *obj) +evas_object_grabs_cleanup(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { if (obj->layer->evas->walking_grabs) { @@ -118,14 +118,15 @@ evas_object_grabs_cleanup(Evas_Object *obj) } void -evas_key_grab_free(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers) +evas_key_grab_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers) { /* MEM OK */ Evas_Key_Grab *g; - g = evas_key_grab_find(obj, keyname, modifiers, not_modifiers, 0); + g = evas_key_grab_find(eo_obj, obj, keyname, modifiers, not_modifiers, 0); if (!g) return; - g->object->grabs = eina_list_remove(g->object->grabs, g); + Evas_Object_Protected_Data *g_object = eo_data_get(g->object, EVAS_OBJ_CLASS); + g_object->grabs = eina_list_remove(g_object->grabs, g); obj->layer->evas->grabs = eina_list_remove(obj->layer->evas->grabs, g); if (g->keyname) free(g->keyname); free(g); @@ -134,46 +135,74 @@ evas_key_grab_free(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask mod /* public calls */ EAPI Eina_Bool -evas_object_key_grab(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive) +evas_object_key_grab(Evas_Object *eo_obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers, Eina_Bool exclusive) { + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EINA_FALSE; + MAGIC_CHECK_END(); + Eina_Bool ret = EINA_FALSE; + eo_do(eo_obj, evas_obj_key_grab(keyname, modifiers, not_modifiers, exclusive, &ret)); + return ret; +} + +void +_key_grab(Eo *eo_obj, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask modifiers = va_arg(*list, Evas_Modifier_Mask); + Evas_Modifier_Mask not_modifiers = va_arg(*list, Evas_Modifier_Mask); + Eina_Bool exclusive = va_arg(*list, int); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + /* MEM OK */ Evas_Key_Grab *g; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - if (!keyname) return EINA_FALSE; + Evas_Object_Protected_Data *obj = _pd; + if (!keyname) + *ret = EINA_FALSE; if (exclusive) { - g = evas_key_grab_find(obj, keyname, modifiers, not_modifiers, + g = evas_key_grab_find(eo_obj, obj, keyname, modifiers, not_modifiers, exclusive); - if (g) return EINA_FALSE; + if (g) + *ret = EINA_FALSE; } - g = evas_key_grab_new(obj, keyname, modifiers, not_modifiers, exclusive); - if (!g) return EINA_FALSE; - return EINA_TRUE; + g = evas_key_grab_new(eo_obj, obj, keyname, modifiers, not_modifiers, exclusive); + *ret = (!g) ? EINA_FALSE : EINA_TRUE; } EAPI void -evas_object_key_ungrab(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers) +evas_object_key_ungrab(Evas_Object *eo_obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers) { + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_key_ungrab(keyname, modifiers, not_modifiers)); +} + +void +_key_ungrab(Eo *eo_obj, void *_pd, va_list *list) +{ + const char *keyname = va_arg(*list, const char *); + Evas_Modifier_Mask modifiers = va_arg(*list, Evas_Modifier_Mask); + Evas_Modifier_Mask not_modifiers = va_arg(*list, Evas_Modifier_Mask); + /* MEM OK */ Evas_Key_Grab *g; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); if (!keyname) return; - g = evas_key_grab_find(obj, keyname, modifiers, not_modifiers, 0); + Evas_Object_Protected_Data *obj = _pd; + g = evas_key_grab_find(eo_obj, obj, keyname, modifiers, not_modifiers, 0); if (!g) return; - if (g->object->layer->evas->walking_grabs) + Evas_Object_Protected_Data *g_object = eo_data_get(g->object, EVAS_OBJ_CLASS); + if (g_object->layer->evas->walking_grabs) { if (!g->delete_me) { - g->object->layer->evas->delete_grabs++; + g_object->layer->evas->delete_grabs++; g->delete_me = EINA_TRUE; } } else - evas_key_grab_free(g->object, keyname, modifiers, not_modifiers); + evas_key_grab_free(g->object, g_object, keyname, modifiers, not_modifiers); } diff --git a/legacy/evas/src/lib/canvas/evas_layer.c b/legacy/evas/src/lib/canvas/evas_layer.c index 7b89069655..fa86aa9334 100644 --- a/legacy/evas/src/lib/canvas/evas_layer.c +++ b/legacy/evas/src/lib/canvas/evas_layer.c @@ -4,7 +4,7 @@ static void _evas_layer_free(Evas_Layer *lay); void -evas_object_inject(Evas_Object *obj, Evas *e) +evas_object_inject(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Evas *e) { Evas_Layer *lay; @@ -16,17 +16,17 @@ evas_object_inject(Evas_Object *obj, Evas *e) lay->layer = obj->cur.layer; evas_layer_add(lay); } - lay->objects = (Evas_Object *)eina_inlist_append(EINA_INLIST_GET(lay->objects), EINA_INLIST_GET(obj)); + lay->objects = (Evas_Object_Protected_Data *)eina_inlist_append(EINA_INLIST_GET(lay->objects), EINA_INLIST_GET(obj)); lay->usage++; obj->layer = lay; obj->in_layer = 1; } void -evas_object_release(Evas_Object *obj, int clean_layer) +evas_object_release(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, int clean_layer) { if (!obj->in_layer) return; - obj->layer->objects = (Evas_Object *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj)); + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj)); obj->layer->usage--; if (clean_layer) { @@ -41,8 +41,9 @@ evas_object_release(Evas_Object *obj, int clean_layer) } Evas_Layer * -evas_layer_new(Evas *e) +evas_layer_new(Evas *eo_e) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Layer *lay; lay = calloc(1, sizeof(Evas_Layer)); @@ -60,12 +61,12 @@ _evas_layer_free(Evas_Layer *lay) void evas_layer_pre_free(Evas_Layer *lay) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_FOREACH(lay->objects, obj) { if ((!obj->smart.parent) && (!obj->delete_me)) - evas_object_del(obj); + evas_object_del(obj->object); } } @@ -74,16 +75,17 @@ evas_layer_free_objects(Evas_Layer *lay) { while (lay->objects) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; - obj = (Evas_Object *)lay->objects; - evas_object_free(obj, 0); + obj = (Evas_Object_Protected_Data *)lay->objects; + evas_object_free(obj->object, 0); } } void -evas_layer_clean(Evas *e) +evas_layer_clean(Evas *eo_e) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Layer *tmp; while (e->layers) @@ -95,8 +97,9 @@ evas_layer_clean(Evas *e) } Evas_Layer * -evas_layer_find(Evas *e, short layer_num) +evas_layer_find(Evas *eo_e, short layer_num) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Layer *layer; EINA_INLIST_FOREACH(e->layers, layer) @@ -127,30 +130,33 @@ evas_layer_add(Evas_Layer *lay) void evas_layer_del(Evas_Layer *lay) { - Evas *e; + Evas_Public_Data *e; e = lay->evas; e->layers = (Evas_Layer *)eina_inlist_remove(EINA_INLIST_GET(e->layers), EINA_INLIST_GET(lay)); } static void -_evas_object_layer_set_child(Evas_Object *obj, Evas_Object *par, short l) +_evas_object_layer_set_child(Evas_Object *eo_obj, Evas_Object *par, short l) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Protected_Data *par_obj = eo_data_get(par, EVAS_OBJ_CLASS); + if (obj->delete_me) return; if (obj->cur.layer == l) return; - evas_object_release(obj, 1); + evas_object_release(eo_obj, obj, 1); obj->cur.layer = l; - obj->layer = par->layer; + obj->layer = par_obj->layer; obj->layer->usage++; - if (obj->smart.smart) + if (obj->is_smart) { Eina_Inlist *contained; - Evas_Object *member; + Evas_Object_Protected_Data *member; - contained = (Eina_Inlist *)evas_object_smart_members_get_direct(obj); + contained = (Eina_Inlist *)evas_object_smart_members_get_direct(eo_obj); EINA_INLIST_FOREACH(contained, member) { - _evas_object_layer_set_child(member, obj, l); + _evas_object_layer_set_child(member->object, eo_obj, l); } } } @@ -158,41 +164,50 @@ _evas_object_layer_set_child(Evas_Object *obj, Evas_Object *par, short l) /* public functions */ EAPI void -evas_object_layer_set(Evas_Object *obj, short l) +evas_object_layer_set(Evas_Object *eo_obj, short l) { - Evas *e; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_layer_set(l)); +} + +void +_layer_set(Eo *eo_obj, void *_obj, va_list *list) +{ + short l = va_arg(*list, int); + + Evas *eo_e; + Evas_Object_Protected_Data *obj = _obj; + if (obj->delete_me) return; - if (evas_object_intercept_call_layer_set(obj, l)) return; + if (evas_object_intercept_call_layer_set(eo_obj, l)) return; if (obj->smart.parent) return; if (obj->cur.layer == l) { - evas_object_raise(obj); + evas_object_raise(eo_obj); return; } - e = obj->layer->evas; - evas_object_release(obj, 1); + eo_e = obj->layer->evas->evas; + evas_object_release(eo_obj, obj, 1); obj->cur.layer = l; - evas_object_inject(obj, e); + evas_object_inject(eo_obj, obj, eo_e); obj->restack = 1; - evas_object_change(obj); + evas_object_change(eo_obj, obj); if (obj->clip.clipees) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } - evas_object_change(obj); - if (!obj->smart.smart) + evas_object_change(eo_obj, obj); + if (!obj->is_smart) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && obj->cur.visible) if (eina_list_data_find(obj->layer->evas->pointer.object.in, obj)) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -201,26 +216,37 @@ evas_object_layer_set(Evas_Object *obj, short l) else { Eina_Inlist *contained; - Evas_Object *member; - - contained = (Eina_Inlist *)evas_object_smart_members_get_direct(obj); + Evas_Object_Protected_Data *member; + + contained = (Eina_Inlist *)evas_object_smart_members_get_direct(eo_obj); EINA_INLIST_FOREACH(contained, member) { - _evas_object_layer_set_child(member, obj, l); + _evas_object_layer_set_child(member->object, eo_obj, l); } } - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); } EAPI short -evas_object_layer_get(const Evas_Object *obj) +evas_object_layer_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); + short layer = 0; + eo_do((Eo *)eo_obj, evas_obj_layer_get(&layer)); + return layer; +} + +void +_layer_get(Eo *eo_obj EINA_UNUSED, void *_obj, va_list *list) +{ + short *layer = va_arg(*list, short *); + const Evas_Object_Protected_Data *obj = _obj; if (obj->smart.parent) { - return obj->smart.parent->cur.layer; + Evas_Object_Protected_Data *smart_parent_obj = eo_data_get(obj->smart.parent, EVAS_OBJ_CLASS); + *layer = smart_parent_obj->cur.layer; } - return obj->cur.layer; + *layer = obj->cur.layer; } diff --git a/legacy/evas/src/lib/canvas/evas_main.c b/legacy/evas/src/lib/canvas/evas_main.c index 94b54bb595..8a7521d3d8 100644 --- a/legacy/evas/src/lib/canvas/evas_main.c +++ b/legacy/evas/src/lib/canvas/evas_main.c @@ -5,6 +5,12 @@ #include "evas_cs2_private.h" #endif +#include + +EAPI Eo_Op EVAS_CANVAS_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_CLASS + #ifdef LKDEBUG EAPI Eina_Bool lockdebug = EINA_FALSE; EAPI int lockmax = 0; @@ -18,6 +24,8 @@ evas_init(void) if (++_evas_init_count != 1) return _evas_init_count; + eo_init(); + #ifdef LKDEBUG if (getenv("EVAS_LOCK_DEBUG")) { @@ -103,6 +111,8 @@ evas_shutdown(void) evil_shutdown(); #endif + eo_shutdown(); + return _evas_init_count; } @@ -110,12 +120,17 @@ evas_shutdown(void) EAPI Evas * evas_new(void) { - Evas *e; + Evas_Object *eo_obj = eo_add(EVAS_CLASS, NULL); + return eo_obj; +} - e = calloc(1, sizeof(Evas)); - if (!e) return NULL; +static void +_constructor(Eo *eo_obj, void *class_data, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); - e->magic = MAGIC_EVAS; + Evas_Public_Data *e = class_data; + e->evas = eo_obj; e->output.render_method = RENDER_METHOD_INVALID; e->viewport.w = 1; e->viewport.h = 1; @@ -142,28 +157,34 @@ evas_new(void) EVAS_ARRAY_SET(e, clip_changes); #undef EVAS_ARRAY_SET - - return e; } EAPI void -evas_free(Evas *e) +evas_free(Evas *eo_e) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_unref(eo_e); +} + +static void +_destructor(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; Eina_Rectangle *r; Evas_Coord_Touch_Point *touch_point; Evas_Layer *lay; int i; int del; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); + if (e->walking_list == 0) evas_render_idle_flush(eo_e); if (e->walking_list > 0) return; - evas_render_idle_flush(e); + evas_render_idle_flush(eo_e); + + _evas_post_event_callback_free(eo_e); - _evas_post_event_callback_free(e); - del = 1; e->walking_list++; e->cleanup = 1; @@ -172,7 +193,7 @@ evas_free(Evas *e) del = 0; EINA_INLIST_FOREACH(e->layers, lay) { - Evas_Object *o; + Evas_Object_Protected_Data *o; evas_layer_pre_free(lay); @@ -192,11 +213,11 @@ evas_free(Evas *e) } EINA_INLIST_FOREACH(e->layers, lay) evas_layer_free_objects(lay); - evas_layer_clean(e); + evas_layer_clean(eo_e); e->walking_list--; - evas_font_path_clear(e); + evas_font_path_clear(eo_e); e->pointer.object.in = eina_list_free(e->pointer.object.in); if (e->name_hash) eina_hash_free(e->name_hash); @@ -207,16 +228,16 @@ evas_free(Evas *e) EINA_LIST_FREE(e->obscures, r) eina_rectangle_free(r); - evas_fonts_zero_free(e); + evas_fonts_zero_free(eo_e); - evas_event_callback_all_del(e); - evas_event_callback_cleanup(e); + evas_event_callback_all_del(eo_e); + evas_event_callback_cleanup(eo_e); if (e->engine.func) { e->engine.func->context_free(e->engine.data.output, e->engine.data.context); e->engine.func->output_free(e->engine.data.output); - e->engine.func->info_free(e, e->engine.info); + e->engine.func->info_free(eo_e, e->engine.info); } for (i = 0; i < e->modifiers.mod.count; i++) @@ -242,20 +263,28 @@ evas_free(Evas *e) EINA_LIST_FREE(e->touch_points, touch_point) free(touch_point); - _evas_device_cleanup(e); + _evas_device_cleanup(eo_e); e->magic = 0; - free(e); + eo_do_super(eo_e, eo_destructor()); } EAPI void -evas_output_method_set(Evas *e, int render_method) +evas_output_method_set(Evas *eo_e, int render_method) { - Evas_Module *em; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_output_method_set(render_method)); +} + +static void +_canvas_output_method_set(Eo *eo_e, void *_pd, va_list *list) +{ + int render_method = va_arg(*list, int); + + Evas_Module *em; + Evas_Public_Data *e = _pd; /* if our engine to set it to is invalid - abort */ if (render_method == RENDER_METHOD_INVALID) return; @@ -275,55 +304,102 @@ evas_output_method_set(Evas *e, int render_method) e->engine.module = em; evas_module_ref(em); /* get the engine info struct */ - if (e->engine.func->info) e->engine.info = e->engine.func->info(e); + if (e->engine.func->info) e->engine.info = e->engine.func->info(eo_e); return; } EAPI int -evas_output_method_get(const Evas *e) +evas_output_method_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return RENDER_METHOD_INVALID; MAGIC_CHECK_END(); + int ret = RENDER_METHOD_INVALID; + eo_do((Eo *)eo_e, evas_canvas_output_method_get(&ret)); + return ret; +} - return e->output.render_method; +static void +_canvas_output_method_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *ret = va_arg(*list, int *); + const Evas_Public_Data *e = _pd; + *ret = e->output.render_method; } EAPI Evas_Engine_Info * -evas_engine_info_get(const Evas *e) +evas_engine_info_get(const Evas *eo_e) { - Evas_Engine_Info *info; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Evas_Engine_Info *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_engine_info_get(&ret)); + return ret; +} - if (!e->engine.info) return NULL; +static void +_canvas_engine_info_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Engine_Info **ret = va_arg(*list, Evas_Engine_Info **); + + Evas_Engine_Info *info; + + const Evas_Public_Data *e = _pd; + if (!e->engine.info) + { + *ret = NULL; + return; + } info = e->engine.info; - ((Evas *)e)->engine.info_magic = info->magic; + ((Evas_Public_Data *)e)->engine.info_magic = info->magic; - return info; + *ret = info; } EAPI Eina_Bool -evas_engine_info_set(Evas *e, Evas_Engine_Info *info) +evas_engine_info_set(Evas *eo_e, Evas_Engine_Info *info) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return EINA_FALSE; MAGIC_CHECK_END(); - if (!info) return EINA_FALSE; - if (info != e->engine.info) return EINA_FALSE; - if (info->magic != e->engine.info_magic) return EINA_FALSE; - return (Eina_Bool)e->engine.func->setup(e, info); + Eina_Bool ret = EINA_FALSE; + eo_do(eo_e, evas_canvas_engine_info_set(info, &ret)); + return ret; +} + +static void +_canvas_engine_info_set(Eo *eo_e, void *_pd, va_list *list) +{ + Evas_Engine_Info *info = va_arg(*list, Evas_Engine_Info *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; + Evas_Public_Data *e = _pd; + if (!info) return; + if (info != e->engine.info) return; + if (info->magic != e->engine.info_magic) return; + + Eina_Bool int_ret = (Eina_Bool)e->engine.func->setup(eo_e, info); + if (ret) *ret = int_ret; } EAPI void -evas_output_size_set(Evas *e, int w, int h) +evas_output_size_set(Evas *eo_e, int w, int h) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_output_size_set(w, h)); +} + +static void +_canvas_output_size_set(Eo *eo_e, void *_pd, va_list *list) +{ + int w = va_arg(*list, int); + int h = va_arg(*list, int); + + Evas_Public_Data *e = _pd; if ((w == e->output.w) && (h == e->output.h)) return; if (w < 1) w = 1; @@ -334,28 +410,50 @@ evas_output_size_set(Evas *e, int w, int h) e->output.changed = 1; e->output_validity++; e->changed = 1; - evas_render_invalidate(e); + evas_render_invalidate(eo_e); } EAPI void -evas_output_size_get(const Evas *e, int *w, int *h) +evas_output_size_get(const Evas *eo_e, int *w, int *h) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_e, evas_canvas_output_size_get(w, h)); +} + +static void +_canvas_output_size_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); + + const Evas_Public_Data *e = _pd; if (w) *w = e->output.w; if (h) *h = e->output.h; } EAPI void -evas_output_viewport_set(Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) +evas_output_viewport_set(Evas *eo_e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_output_viewport_set(x, y, w, h)); +} + +static void +_canvas_output_viewport_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + + Evas_Public_Data *e = _pd; if ((x == e->viewport.x) && (y == e->viewport.y) && (w == e->viewport.w) && (h == e->viewport.h)) return; @@ -377,15 +475,27 @@ evas_output_viewport_set(Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas } EAPI void -evas_output_viewport_get(const Evas *e, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) +evas_output_viewport_get(const Evas *eo_e, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_e, evas_canvas_output_viewport_get(x, y, w, h)); +} + +static void +_canvas_output_viewport_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *x = va_arg(*list, Evas_Coord *); + Evas_Coord *y = va_arg(*list, Evas_Coord *); + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + + const Evas_Public_Data *e = _pd; if (x) *x = e->viewport.x; if (y) *y = e->viewport.y; @@ -393,12 +503,24 @@ evas_output_viewport_get(const Evas *e, Evas_Coord *x, Evas_Coord *y, Evas_Coord if (h) *h = e->viewport.h; } -EAPI void -evas_output_framespace_set(Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) +EAPI void +evas_output_framespace_set(Evas *eo_e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_output_framespace_set(x, y, w, h)); +} + +static void +_canvas_output_framespace_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + + Evas_Public_Data *e = _pd; if ((x == e->framespace.x) && (y == e->framespace.y) && (w == e->framespace.w) && (h == e->framespace.h)) return; @@ -411,16 +533,28 @@ evas_output_framespace_set(Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Ev e->changed = 1; } -EAPI void -evas_output_framespace_get(const Evas *e, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) +EAPI void +evas_output_framespace_get(const Evas *eo_e, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_e, evas_canvas_output_framespace_get(x, y, w, h)); +} + +static void +_canvas_output_framespace_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *x = va_arg(*list, Evas_Coord *); + Evas_Coord *y = va_arg(*list, Evas_Coord *); + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + + const Evas_Public_Data *e = _pd; if (x) *x = e->framespace.x; if (y) *y = e->framespace.y; @@ -429,43 +563,91 @@ evas_output_framespace_get(const Evas *e, Evas_Coord *x, Evas_Coord *y, Evas_Coo } EAPI Evas_Coord -evas_coord_screen_x_to_world(const Evas *e, int x) +evas_coord_screen_x_to_world(const Evas *eo_e, int x) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - if (e->output.w == e->viewport.w) return e->viewport.x + x; - return (long long)e->viewport.x + (((long long)x * (long long)e->viewport.w) / (long long)e->output.w); + Evas_Coord ret = 0; + eo_do((Eo *)eo_e, evas_canvas_coord_screen_x_to_world(x, &ret)); + return ret; +} + +static void +_canvas_coord_screen_x_to_world(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int x = va_arg(*list, int); + Evas_Coord *ret = va_arg(*list, Evas_Coord *); + + const Evas_Public_Data *e = _pd; + if (e->output.w == e->viewport.w) *ret = e->viewport.x + x; + else *ret = (long long)e->viewport.x + (((long long)x * (long long)e->viewport.w) / (long long)e->output.w); } EAPI Evas_Coord -evas_coord_screen_y_to_world(const Evas *e, int y) +evas_coord_screen_y_to_world(const Evas *eo_e, int y) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - if (e->output.h == e->viewport.h) return e->viewport.y + y; - return (long long)e->viewport.y + (((long long)y * (long long)e->viewport.h) / (long long)e->output.h); + Evas_Coord ret = 0; + eo_do((Eo *)eo_e, evas_canvas_coord_screen_y_to_world(y, &ret)); + return ret; +} + +static void +_canvas_coord_screen_y_to_world(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int y = va_arg(*list, int); + Evas_Coord *ret = va_arg(*list, Evas_Coord *); + + const Evas_Public_Data *e = _pd; + if (e->output.h == e->viewport.h) *ret = e->viewport.y + y; + else *ret = (long long)e->viewport.y + (((long long)y * (long long)e->viewport.h) / (long long)e->output.h); } EAPI int -evas_coord_world_x_to_screen(const Evas *e, Evas_Coord x) +evas_coord_world_x_to_screen(const Evas *eo_e, Evas_Coord x) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - if (e->output.w == e->viewport.w) return x - e->viewport.x; - return (int)((((long long)x - (long long)e->viewport.x) * (long long)e->output.w) / (long long)e->viewport.w); + Evas_Coord ret = 0; + eo_do((Eo *)eo_e, evas_canvas_coord_world_x_to_screen(x, &ret)); + return ret; +} + +static void +_canvas_coord_world_x_to_screen(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + int *ret = va_arg(*list, int *); + + const Evas_Public_Data *e = _pd; + if (e->output.w == e->viewport.w) *ret = x - e->viewport.x; + else *ret = (int)((((long long)x - (long long)e->viewport.x) * (long long)e->output.w) / (long long)e->viewport.w); } EAPI int -evas_coord_world_y_to_screen(const Evas *e, Evas_Coord y) +evas_coord_world_y_to_screen(const Evas *eo_e, Evas_Coord y) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - if (e->output.h == e->viewport.h) return y - e->viewport.y; - return (int)((((long long)y - (long long)e->viewport.y) * (long long)e->output.h) / (long long)e->viewport.h); + Evas_Coord ret = 0; + eo_do((Eo *)eo_e, evas_canvas_coord_world_y_to_screen(y, &ret)); + return ret; +} + +static void +_canvas_coord_world_y_to_screen(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord y = va_arg(*list, Evas_Coord); + int *ret = va_arg(*list, int *); + + const Evas_Public_Data *e = _pd; + if (e->output.h == e->viewport.h) *ret = y - e->viewport.y; + else *ret = (int)((((long long)y - (long long)e->viewport.y) * (long long)e->output.h) / (long long)e->viewport.h); } EAPI int @@ -515,119 +697,216 @@ evas_object_image_extension_can_load_fast_get(const char *file) } EAPI void -evas_pointer_output_xy_get(const Evas *e, int *x, int *y) +evas_pointer_output_xy_get(const Evas *eo_e, int *x, int *y) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); if (x) *x = 0; if (y) *y = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_e, evas_canvas_pointer_output_xy_get(x, y)); +} + +static void +_canvas_pointer_output_xy_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *x = va_arg(*list, int *); + int *y = va_arg(*list, int *); + const Evas_Public_Data *e = _pd; if (x) *x = e->pointer.x; if (y) *y = e->pointer.y; } EAPI void -evas_pointer_canvas_xy_get(const Evas *e, Evas_Coord *x, Evas_Coord *y) +evas_pointer_canvas_xy_get(const Evas *eo_e, Evas_Coord *x, Evas_Coord *y) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); if (x) *x = 0; if (y) *y = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_e, evas_canvas_pointer_canvas_xy_get(x, y)); +} + +static void +_canvas_pointer_canvas_xy_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *x = va_arg(*list, Evas_Coord *); + Evas_Coord *y = va_arg(*list, Evas_Coord *); + + const Evas_Public_Data *e = _pd; if (x) *x = e->pointer.x; if (y) *y = e->pointer.y; } EAPI int -evas_pointer_button_down_mask_get(const Evas *e) +evas_pointer_button_down_mask_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return (int)e->pointer.button; + int ret = 0; + eo_do((Eo *)eo_e, evas_canvas_pointer_button_down_mask_get(&ret)); + return ret; +} + +static void +_canvas_pointer_button_down_mask_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *ret = va_arg(*list, int *); + + const Evas_Public_Data *e = _pd; + *ret = (int)e->pointer.button; } EAPI Eina_Bool -evas_pointer_inside_get(const Evas *e) +evas_pointer_inside_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return (int)e->pointer.inside; + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)eo_e, evas_canvas_pointer_inside_get(&ret)); + return ret; +} + +static void +_canvas_pointer_inside_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + + const Evas_Public_Data *e = _pd; + *ret = (int)e->pointer.inside; } EAPI void -evas_data_attach_set(Evas *e, void *data) +evas_data_attach_set(Evas *eo_e, void *data) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_data_attach_set(data)); +} + +static void +_canvas_data_attach_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + void *data = va_arg(*list, void *); + Evas_Public_Data *e = _pd; e->attach_data = data; } EAPI void * -evas_data_attach_get(const Evas *e) +evas_data_attach_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - return e->attach_data; + void *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_data_attach_get(&ret)); + return ret; +} + +static void +_canvas_data_attach_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + void **ret = va_arg(*list, void **); + const Evas_Public_Data *e = _pd; + *ret = e->attach_data; } EAPI void -evas_focus_in(Evas *e) +evas_focus_in(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_focus_in()); +} + +static void +_canvas_focus_in(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; if (e->focus) return; e->focus = 1; - evas_event_callback_call(e, EVAS_CALLBACK_CANVAS_FOCUS_IN, NULL); + evas_event_callback_call(eo_e, EVAS_CALLBACK_CANVAS_FOCUS_IN, NULL); } EAPI void -evas_focus_out(Evas *e) +evas_focus_out(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_focus_out()); +} + +static void +_canvas_focus_out(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; if (!e->focus) return; e->focus = 0; - evas_event_callback_call(e, EVAS_CALLBACK_CANVAS_FOCUS_OUT, NULL); + evas_event_callback_call(eo_e, EVAS_CALLBACK_CANVAS_FOCUS_OUT, NULL); } EAPI Eina_Bool -evas_focus_state_get(const Evas *e) +evas_focus_state_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return e->focus; + Eina_Bool ret = 0; + eo_do((Eo *)eo_e, evas_canvas_focus_state_get(&ret)); + return ret; +} + +static void +_canvas_focus_state_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + const Evas_Public_Data *e = _pd; + *ret = e->focus; } EAPI void -evas_nochange_push(Evas *e) +evas_nochange_push(Evas *eo_e) { + eo_do(eo_e, evas_canvas_nochange_push()); +} + +static void +_canvas_nochange_push(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; e->nochange++; } EAPI void -evas_nochange_pop(Evas *e) +evas_nochange_pop(Evas *eo_e) { + eo_do(eo_e, evas_canvas_nochange_pop()); +} + +static void +_canvas_nochange_pop(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; e->nochange--; } void -_evas_walk(Evas *e) +_evas_walk(Evas_Public_Data *e) { e->walking_list++; } void -_evas_unwalk(Evas *e) +_evas_unwalk(Evas_Public_Data *e) { e->walking_list--; - if ((e->walking_list == 0) && (e->delete_me)) evas_free(e); + if ((e->walking_list == 0) && (e->delete_me)) evas_free(e->evas); } EAPI const char * @@ -691,3 +970,225 @@ evas_data_argb_unpremul(unsigned int *data, unsigned int len) if (!data || (len < 1)) return; evas_common_convert_argb_unpremul(data, len); } + +static void +_evas_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas **evas = va_arg(*list, Evas **); + if (evas) *evas = (Evas *)eo_obj; +} + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_COMMON_ID(EVAS_COMMON_SUB_ID_EVAS_GET), _evas_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_SET), _canvas_output_method_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_GET), _canvas_output_method_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_ENGINE_INFO_GET), _canvas_engine_info_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_ENGINE_INFO_SET), _canvas_engine_info_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_SET), _canvas_output_size_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_GET), _canvas_output_size_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_SET), _canvas_output_viewport_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_GET), _canvas_output_viewport_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_SET), _canvas_output_framespace_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_GET), _canvas_output_framespace_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_SCREEN_X_TO_WORLD), _canvas_coord_screen_x_to_world), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_SCREEN_Y_TO_WORLD), _canvas_coord_screen_y_to_world), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_WORLD_X_TO_SCREEN), _canvas_coord_world_x_to_screen), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_COORD_WORLD_Y_TO_SCREEN), _canvas_coord_world_y_to_screen), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_OUTPUT_XY_GET), _canvas_pointer_output_xy_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_CANVAS_XY_GET), _canvas_pointer_canvas_xy_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_BUTTON_DOWN_MASK_GET), _canvas_pointer_button_down_mask_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_POINTER_INSIDE_GET), _canvas_pointer_inside_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DATA_ATTACH_SET), _canvas_data_attach_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DATA_ATTACH_GET), _canvas_data_attach_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_IN), _canvas_focus_in), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_OUT), _canvas_focus_out), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_STATE_GET), _canvas_focus_state_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_NOCHANGE_PUSH), _canvas_nochange_push), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_NOCHANGE_POP), _canvas_nochange_pop), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_SET), _canvas_event_default_flags_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_GET), _canvas_event_default_flags_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_DOWN), _canvas_event_feed_mouse_down), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_UP), _canvas_event_feed_mouse_up), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_CANCEL), _canvas_event_feed_mouse_cancel), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_WHEEL), _canvas_event_feed_mouse_wheel), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_MOVE), _canvas_event_feed_mouse_move), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_IN), _canvas_event_feed_mouse_in), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_OUT), _canvas_event_feed_mouse_out), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_DOWN), _canvas_event_feed_multi_down), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_UP), _canvas_event_feed_multi_up), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_MOVE), _canvas_event_feed_multi_move), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_DOWN), _canvas_event_feed_key_down), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_UP), _canvas_event_feed_key_up), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_FEED_HOLD), _canvas_event_feed_hold), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_REFEED_EVENT), _canvas_event_refeed_event), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_EVENT_DOWN_COUNT_GET), _canvas_event_down_count_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FOCUS_GET), _canvas_focus_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_CLEAR), _canvas_font_path_clear), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_APPEND), _canvas_font_path_append), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_PREPEND), _canvas_font_path_prepend), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_PATH_LIST), _canvas_font_path_list), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_HINTING_SET), _canvas_font_hinting_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_HINTING_GET), _canvas_font_hinting_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_HINTING_CAN_HINT), _canvas_font_hinting_can_hint), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_CACHE_FLUSH), _canvas_font_cache_flush), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_CACHE_SET), _canvas_font_cache_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_CACHE_GET), _canvas_font_cache_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_FONT_AVAILABLE_LIST), _canvas_font_available_list), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_GET), _canvas_key_modifier_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_GET), _canvas_key_lock_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ADD), _canvas_key_modifier_add), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_DEL), _canvas_key_modifier_del), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_ADD), _canvas_key_lock_add), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_DEL), _canvas_key_lock_del), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ON), _canvas_key_modifier_on), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_OFF), _canvas_key_modifier_off), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_ON), _canvas_key_lock_on), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_LOCK_OFF), _canvas_key_lock_off), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_MASK_GET), _canvas_key_modifier_mask_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_DAMAGE_RECTANGLE_ADD), _canvas_damage_rectangle_add), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBSCURED_RECTANGLE_ADD), _canvas_obscured_rectangle_add), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBSCURED_CLEAR), _canvas_obscured_clear), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER_UPDATES), _canvas_render_updates), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER), _canvas_render), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_NORENDER), _canvas_norender), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER_IDLE_FLUSH), _canvas_render_idle_flush), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_SYNC), _canvas_sync), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_RENDER_DUMP), _canvas_render_dump), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_BOTTOM_GET), _canvas_object_bottom_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_TOP_GET), _canvas_object_top_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_COUNT), _canvas_touch_point_list_count), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_XY_GET), _canvas_touch_point_list_nth_xy_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_ID_GET), _canvas_touch_point_list_nth_id_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_STATE_GET), _canvas_touch_point_list_nth_state_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_FLUSH), _canvas_image_cache_flush), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_RELOAD), _canvas_image_cache_reload), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_SET), _canvas_image_cache_set), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_GET), _canvas_image_cache_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_IMAGE_MAX_SIZE_GET), _canvas_image_max_size_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_NAME_FIND), _canvas_object_name_find), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_TOP_AT_XY_GET), _canvas_object_top_at_xy_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECT_TOP_IN_RECTANGLE_GET), _canvas_object_top_in_rectangle_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECTS_AT_XY_GET), _canvas_objects_at_xy_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_OBJECTS_IN_RECTANGLE_GET), _canvas_objects_in_rectangle_get), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE), _canvas_smart_objects_calculate), + EO_OP_FUNC(EVAS_CANVAS_ID(EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE_COUNT_GET), _canvas_smart_objects_calculate_count_get), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_SET, "Sets the output engine for the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_METHOD_GET, "Retrieves the number of the output engine used for the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_ENGINE_INFO_GET, "Retrieves the current render engine info struct from the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_ENGINE_INFO_SET, "Applies the engine settings for the given evas from the given Evas_Engine_Info structure."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_SET, "Sets the output size of the render engine of the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_SIZE_GET, "Retrieve the output size of the render engine of the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_SET, "Sets the output viewport of the given evas in evas units."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_VIEWPORT_GET, "Get the render engine's output viewport co-ordinates in canvas units."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_SET, "Sets the output framespace size of the render engine of the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OUTPUT_FRAMESPACE_GET, "Get the render engine's output framespace co-ordinates in canvas units."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_COORD_SCREEN_X_TO_WORLD, "Convert/scale an ouput screen co-ordinate into canvas co-ordinates"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_COORD_SCREEN_Y_TO_WORLD, "Convert/scale an ouput screen co-ordinate into canvas co-ordinates"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_COORD_WORLD_X_TO_SCREEN, "Convert/scale a canvas co-ordinate into output screen co-ordinates"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_COORD_WORLD_Y_TO_SCREEN, "Convert/scale a canvas co-ordinate into output screen co-ordinates"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_POINTER_OUTPUT_XY_GET, "This function returns the current known pointer co-ordinates"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_POINTER_CANVAS_XY_GET, "This function returns the current known pointer co-ordinates"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_POINTER_BUTTON_DOWN_MASK_GET, "Returns a bitmask with the mouse buttons currently pressed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_POINTER_INSIDE_GET, "Returns whether the mouse pointer is logically inside the canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_DATA_ATTACH_SET, "Attaches a specific pointer to the evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_DATA_ATTACH_GET, "Returns the pointer attached by evas_data_attach_set()."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FOCUS_IN, "Inform to the evas that it got the focus."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FOCUS_OUT, "Inform to the evas that it lost the focus."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FOCUS_STATE_GET, "Get the focus state known by the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_NOCHANGE_PUSH, "Push the nochange flag up 1."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_NOCHANGE_POP, "Pop the nochange flag down 1."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_SET, "Set the default set of flags an event begins with."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_DEFAULT_FLAGS_GET, "Get the defaulty set of flags an event begins with."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_DOWN, "Mouse down event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_UP, "Mouse up event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_CANCEL, "Mouse cancel event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_WHEEL, "Mouse wheel event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_MOVE, "Mouse move event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_IN, "Mouse in event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MOUSE_OUT, "Mouse out event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_DOWN, "Multi down event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_UP, "Multi up event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_MULTI_MOVE, "Multi move event feed."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_DOWN, "Key down event feed"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_KEY_UP, "Key up event feed"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_FEED_HOLD, "Hold event feed"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_REFEED_EVENT, "Re feed event."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_EVENT_DOWN_COUNT_GET, "Get the number of mouse or multi presses currently active."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FOCUS_GET, "Retrieve the object that currently has focus."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_PATH_CLEAR, "Removes all font paths loaded into memory for the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_PATH_APPEND, "Appends a font path to the list of font paths used by the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_PATH_PREPEND, "Prepends a font path to the list of font paths used by the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_PATH_LIST, "Retrieves the list of font paths used by the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_HINTING_SET, "Changes the font hinting for the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_HINTING_GET, "Retrieves the font hinting used by the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_HINTING_CAN_HINT, "Checks if the font hinting is supported by the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_CACHE_FLUSH, "Force the given evas and associated engine to flush its font cache."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_CACHE_SET, "Changes the size of font cache of the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_CACHE_GET, "Changes the size of font cache of the given evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_FONT_AVAILABLE_LIST, "List of available font descriptions known or found by this evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_GET, "Returns a handle to the list of modifier keys registered."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_LOCK_GET, "Returns a handle to the list of lock keys registered in the canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ADD, "Adds the keyname key to the current list of modifier keys."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_DEL, "Removes the keyname key from the current list of modifier keys."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_LOCK_ADD, "Adds the keyname key to the current list of lock keys."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_LOCK_DEL, "Removes the keyname key from the current list of lock keys."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_ON, "Enables or turns on programmatically the modifier key with name keyname."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_OFF, "Disables or turns off programmatically the modifier key with name keyname."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_LOCK_ON, "Enables or turns on programmatically the lock key with name keyname."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_LOCK_OFF, "Disables or turns off programmatically the lock key with name keyname."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_KEY_MODIFIER_MASK_GET, "Creates a bit mask from the keyname modifier key."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_DAMAGE_RECTANGLE_ADD, "Add a damage rectangle."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBSCURED_RECTANGLE_ADD, "Add an obscured region to an Evas canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBSCURED_CLEAR, "Remove all obscured regions from an Evas canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_RENDER_UPDATES, "Force immediate renderization of the given Evas canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_RENDER, "Force renderization of the given canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_NORENDER, "Update the canvas internal objects but not triggering immediate."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_RENDER_IDLE_FLUSH, "Make the canvas discard internally cached data used for rendering."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_SYNC, "? evas_sync"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_RENDER_DUMP, "Make the canvas discard as much data as possible used by the engine at"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECT_BOTTOM_GET, "Get the lowest (stacked) Evas object on the canvas e."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECT_TOP_GET, "Get the highest (stacked) Evas object on the canvas e."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_COUNT, "Get the number of touched point in the evas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_XY_GET, "This function returns the nth touch point's co-ordinates."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_ID_GET, "This function returns the id of nth touch point."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_TOUCH_POINT_LIST_NTH_STATE_GET, "This function returns the state of nth touch point."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_FLUSH, "Flush the image cache of the canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_RELOAD, "Reload the image cache"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_SET, "Set the image cache."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_IMAGE_CACHE_GET, "Get the image cache"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_IMAGE_MAX_SIZE_GET, "Get the maximum image size evas can possibly handle"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECT_NAME_FIND, "Retrieves the object on the given evas with the given name."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECT_TOP_AT_XY_GET, "Retrieve the Evas object stacked at the top of a given position in"), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECT_TOP_IN_RECTANGLE_GET, "Retrieve the Evas object stacked at the top of a given rectangulari region in a canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECTS_AT_XY_GET, "Retrieve a list of Evas objects lying over a given position in a canvas."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_OBJECTS_IN_RECTANGLE_GET, "Retrieves the objects in the given rectangle region."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE, "Call user-provided calculate() smart functions."), + EO_OP_DESCRIPTION(EVAS_CANVAS_SUB_ID_SMART_OBJECTS_CALCULATE_COUNT_GET, "Get the internal counter that counts the number of smart calculations."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_CANVAS_BASE_ID, op_desc, EVAS_CANVAS_SUB_ID_LAST), + NULL, + sizeof(Evas_Public_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_class_get, &class_desc, EO_BASE_CLASS, EVAS_COMMON_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_map.c b/legacy/evas/src/lib/canvas/evas_map.c index 4466d8a4dc..3338d37046 100644 --- a/legacy/evas/src/lib/canvas/evas_map.c +++ b/legacy/evas/src/lib/canvas/evas_map.c @@ -3,39 +3,40 @@ #include static void -_evas_map_calc_geom_change(Evas_Object *obj) +_evas_map_calc_geom_change(Evas_Object *eo_obj) { int is, was = 0; - - evas_object_change(obj); - evas_object_clip_dirty(obj); - if (obj->layer->evas->events_frozen <= 0) + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + if (!(obj->layer->evas->is_frozen)) { - evas_object_recalc_clippees(obj); - if (!obj->smart.smart) + evas_object_recalc_clippees(eo_obj, obj); + if (!obj->is_smart) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is ^ was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } } - evas_object_inform_call_move(obj); - evas_object_inform_call_resize(obj); + evas_object_inform_call_move(eo_obj, obj); + evas_object_inform_call_resize(eo_obj); } static void -_evas_map_calc_map_geometry(Evas_Object *obj) +_evas_map_calc_map_geometry(Evas_Object *eo_obj) { Evas_Coord x1, x2, yy1, yy2; const Evas_Map_Point *p, *p_end; Eina_Bool ch = EINA_FALSE; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->cur.map) return; // WARN: Do not merge below code to SLP until it is fixed. // It has an infinite loop bug. @@ -99,8 +100,8 @@ _evas_map_calc_map_geometry(Evas_Object *obj) // This shouldn't really be needed, but without it we do have case // where the clip is wrong when a map doesn't change, so always forcing // it, as long as someone doesn't find a better fix. - evas_object_clip_dirty(obj); - if (ch) _evas_map_calc_geom_change(obj); + evas_object_clip_dirty(eo_obj, obj); + if (ch) _evas_map_calc_geom_change(eo_obj); } static inline Evas_Map * @@ -162,10 +163,11 @@ _evas_map_dup(const Evas_Map *orig) } static inline void -_evas_map_free(Evas_Object *obj, Evas_Map *m) +_evas_map_free(Evas_Object *eo_obj, Evas_Map *m) { - if (obj) + if (eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (obj->spans) { obj->layer->evas->engine.func->image_map_clean(obj->layer->evas->engine.data.output, obj->spans); @@ -367,13 +369,13 @@ evas_map_inside_get(const Evas_Map *m, Evas_Coord x, Evas_Coord y) } static Eina_Bool -_evas_object_map_parent_check(Evas_Object *parent) +_evas_object_map_parent_check(Evas_Object *eo_parent) { const Eina_Inlist *list; - const Evas_Object *o; - - if (!parent) return EINA_FALSE; + const Evas_Object_Protected_Data *o; + if (!eo_parent) return EINA_FALSE; + Evas_Object_Protected_Data *parent = eo_data_get(eo_parent, EVAS_OBJ_CLASS); list = evas_object_smart_members_get_direct(parent->smart.parent); EINA_INLIST_FOREACH(list, o) if (o->cur.usemap) break ; @@ -384,12 +386,20 @@ _evas_object_map_parent_check(Evas_Object *parent) } EAPI void -evas_object_map_enable_set(Evas_Object *obj, Eina_Bool enabled) +evas_object_map_enable_set(Evas_Object *eo_obj, Eina_Bool enabled) { - Evas_Object *parents; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_map_enable_set(enabled)); +} + +void +_map_enable_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool enabled = va_arg(*list, int); + + Evas_Object_Protected_Data *obj = _pd; Eina_Bool pchange = EINA_FALSE; enabled = !!enabled; @@ -400,7 +410,7 @@ evas_object_map_enable_set(Evas_Object *obj, Eina_Bool enabled) { if (!obj->cur.map) obj->cur.map = _evas_map_new(4); - evas_object_mapped_clip_across_mark(obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); // obj->cur.map->normal_geometry = obj->cur.geometry; } else @@ -414,44 +424,67 @@ evas_object_map_enable_set(Evas_Object *obj, Eina_Bool enabled) } if (obj->cur.map) { - _evas_map_calc_geom_change(obj); - evas_object_mapped_clip_across_mark(obj); + _evas_map_calc_geom_change(eo_obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); } } - _evas_map_calc_map_geometry(obj); + _evas_map_calc_map_geometry(eo_obj); /* This is a bit heavy handed, but it fixes the case of same geometry, but * changed colour or UV settings. */ - evas_object_change(obj); + evas_object_change(eo_obj, obj); if (!obj->changed_pchange) obj->changed_pchange = pchange; obj->changed_map = EINA_TRUE; if (enabled) { - for (parents = obj->smart.parent; parents; parents = parents->smart.parent) - parents->child_has_map = EINA_TRUE; + Evas_Object *eo_parents; + Evas_Object_Protected_Data *parents = NULL; + for (eo_parents = obj->smart.parent; eo_parents; eo_parents = parents->smart.parent) + { + parents = eo_data_get(eo_parents, EVAS_OBJ_CLASS); + parents->child_has_map = EINA_TRUE; + } } else { if (_evas_object_map_parent_check(obj->smart.parent)) - evas_object_update_bounding_box(obj); + evas_object_update_bounding_box(eo_obj, obj); } } EAPI Eina_Bool -evas_object_map_enable_get(const Evas_Object *obj) +evas_object_map_enable_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - return obj->cur.usemap; + Eina_Bool enabled = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_map_enable_get(&enabled)); + return enabled; +} + +void +_map_enable_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *enabled = va_arg(*list, Eina_Bool *); + const Evas_Object_Protected_Data *obj = _pd; + *enabled = obj->cur.usemap; } EAPI void -evas_object_map_set(Evas_Object *obj, const Evas_Map *map) +evas_object_map_set(Evas_Object *eo_obj, const Evas_Map *map) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_map_set(map)); +} + +void +_map_set(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Map *map = va_arg(*list, const Evas_Map *); + Evas_Object_Protected_Data *obj = _pd; if ((!map) || (map->count < 4)) { @@ -476,20 +509,20 @@ evas_object_map_set(Evas_Object *obj, const Evas_Map *map) } else { - _evas_map_free(obj, obj->cur.map); + _evas_map_free(eo_obj, obj->cur.map); obj->cur.map = NULL; } if (!obj->prev.map) { - evas_object_mapped_clip_across_mark(obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); return; } - if (!obj->cur.usemap) _evas_map_calc_geom_change(obj); - else _evas_map_calc_map_geometry(obj); + if (!obj->cur.usemap) _evas_map_calc_geom_change(eo_obj); + else _evas_map_calc_map_geometry(eo_obj); if (obj->cur.usemap) - evas_object_mapped_clip_across_mark(obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); } return; } @@ -508,23 +541,33 @@ evas_object_map_set(Evas_Object *obj, const Evas_Map *map) _evas_map_copy(obj->cur.map, map); else { - if (obj->cur.map) _evas_map_free(obj, obj->cur.map); + if (obj->cur.map) _evas_map_free(eo_obj, obj->cur.map); obj->cur.map = _evas_map_dup(map); if (obj->cur.usemap) - evas_object_mapped_clip_across_mark(obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); } - _evas_map_calc_map_geometry(obj); + _evas_map_calc_map_geometry(eo_obj); } EAPI const Evas_Map * -evas_object_map_get(const Evas_Object *obj) +evas_object_map_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + const Evas_Map *map = NULL; + eo_do((Eo *)eo_obj, evas_obj_map_get(&map)); + return map; +} - return obj->cur.map; +void +_map_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Map **map = va_arg(*list, const Evas_Map **); + const Evas_Object_Protected_Data *obj = _pd; + + *map = obj->cur.map; } EAPI Evas_Map * @@ -717,11 +760,12 @@ evas_map_point_color_get(const Evas_Map *m, int idx, int *r, int *g, int *b, int } EAPI void -evas_map_util_points_populate_from_object_full(Evas_Map *m, const Evas_Object *obj, Evas_Coord z) +evas_map_util_points_populate_from_object_full(Evas_Map *m, const Evas_Object *eo_obj, Evas_Coord z) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (m->count != 4) { @@ -733,15 +777,16 @@ evas_map_util_points_populate_from_object_full(Evas_Map *m, const Evas_Object *o } EAPI void -evas_map_util_points_populate_from_object(Evas_Map *m, const Evas_Object *obj) +evas_map_util_points_populate_from_object(Evas_Map *m, const Evas_Object *eo_obj) { MAGIC_CHECK(m, Evas_Map, MAGIC_MAP); return; MAGIC_CHECK_END(); - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (m->count != 4) { @@ -1092,11 +1137,12 @@ evas_map_util_clockwise_get(Evas_Map *m) } void -evas_object_map_update(Evas_Object *obj, +evas_object_map_update(Evas_Object *eo_obj, int x, int y, int imagew, int imageh, int uvw, int uvh) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); const Evas_Map_Point *p, *p_end; RGBA_Map_Point *pts, *pt; diff --git a/legacy/evas/src/lib/canvas/evas_name.c b/legacy/evas/src/lib/canvas/evas_name.c index 1a9d20f8b9..5e2d92eede 100644 --- a/legacy/evas/src/lib/canvas/evas_name.c +++ b/legacy/evas/src/lib/canvas/evas_name.c @@ -2,31 +2,50 @@ #include "evas_private.h" EAPI void -evas_object_name_set(Evas_Object *obj, const char *name) +evas_object_name_set(Evas_Object *eo_obj, const char *name) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_name_set(name)); +} + +void +_name_set(Eo *eo_obj, void *_pd, va_list *list) +{ + const char *name = va_arg(*list, const char *); + + Evas_Object_Protected_Data *obj = _pd; if (obj->name) { - eina_hash_del(obj->layer->evas->name_hash, obj->name, obj); + eina_hash_del(obj->layer->evas->name_hash, obj->name, eo_obj); free(obj->name); } if (!name) obj->name = NULL; else { obj->name = strdup(name); - eina_hash_add(obj->layer->evas->name_hash, obj->name, obj); + eina_hash_add(obj->layer->evas->name_hash, obj->name, eo_obj); } } EAPI const char * -evas_object_name_get(const Evas_Object *obj) +evas_object_name_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - return obj->name; + const char *name = NULL; + eo_do((Eo *)eo_obj, evas_obj_name_get(&name)); + return name; +} + +void +_name_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const char **name = va_arg(*list, const char **); + const Evas_Object_Protected_Data *obj = _pd; + *name = obj->name; } EAPI Evas_Object * @@ -35,38 +54,59 @@ evas_object_name_find(const Evas *e, const char *name) MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - if (!name) return NULL; - return (Evas_Object *)eina_hash_find(e->name_hash, name); + Evas_Object *ret = NULL; + eo_do((Eo *)e, evas_canvas_object_name_find(name, &ret)); + return ret; +} + +void +_canvas_object_name_find(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + const char *name = va_arg(*list, const char *); + Evas_Object **ret = va_arg(*list, Evas_Object **); + const Evas_Public_Data *e = _pd; + if (!name) *ret = NULL; + else *ret = (Evas_Object *)eina_hash_find(e->name_hash, name); } static Evas_Object * -_evas_object_name_child_find(const Evas_Object *obj, const char *name, int recurse) +_evas_object_name_child_find(const Evas_Object *eo_obj, const char *name, int recurse) { const Eina_Inlist *lst; - Evas_Object *child; - - if (!obj->smart.smart) return NULL; - lst = evas_object_smart_members_get_direct(obj); + Evas_Object_Protected_Data *child; + + if (!eo_isa(eo_obj, EVAS_OBJ_SMART_CLASS)) return NULL; + lst = evas_object_smart_members_get_direct(eo_obj); EINA_INLIST_FOREACH(lst, child) { if (child->delete_me) continue; if (!child->name) continue; - if (!strcmp(name, child->name)) return child; + if (!strcmp(name, child->name)) return child->object; if (recurse != 0) { - if ((obj = _evas_object_name_child_find(child, name, recurse - 1))) - return (Evas_Object *)obj; + if ((eo_obj = _evas_object_name_child_find(child->object, name, recurse - 1))) + return (Evas_Object *)eo_obj; } } return NULL; } EAPI Evas_Object * -evas_object_name_child_find(const Evas_Object *obj, const char *name, int recurse) +evas_object_name_child_find(const Evas_Object *eo_obj, const char *name, int recurse) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - if (!name) return NULL; - return _evas_object_name_child_find(obj, name, recurse); + Evas_Object *child = NULL; + eo_do((Eo *)eo_obj, evas_obj_name_child_find(name, recurse, &child)); + return child; +} + +void +_name_child_find(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + const char *name = va_arg(*list, const char *); + int recurse = va_arg(*list, int); + Evas_Object **child = va_arg(*list, Evas_Object **); + *child = (!name ? NULL : _evas_object_name_child_find(eo_obj, name, recurse)); } diff --git a/legacy/evas/src/lib/canvas/evas_object_box.c b/legacy/evas/src/lib/canvas/evas_object_box.c index e29c5f5d63..d2ab6e5235 100644 --- a/legacy/evas/src/lib/canvas/evas_object_box.c +++ b/legacy/evas/src/lib/canvas/evas_object_box.c @@ -1,9 +1,16 @@ #include "evas_common.h" +#include "evas_private.h" #ifdef _WIN32_WCE # undef remove #endif +#include + +EAPI Eo_Op EVAS_OBJ_BOX_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_BOX_CLASS + typedef struct _Evas_Object_Box_Iterator Evas_Object_Box_Iterator; typedef struct _Evas_Object_Box_Accessor Evas_Object_Box_Accessor; @@ -38,7 +45,7 @@ static const Evas_Smart_Cb_Description _signals[] = static void _sizing_eval(Evas_Object *obj); #define EVAS_OBJECT_BOX_DATA_GET(o, ptr) \ - Evas_Object_Box_Data *ptr = evas_object_smart_data_get(o) + Evas_Object_Box_Data *ptr = eo_data_get(o, MY_CLASS) #define EVAS_OBJECT_BOX_DATA_GET_OR_RETURN(o, ptr) \ EVAS_OBJECT_BOX_DATA_GET(o, ptr); \ @@ -60,10 +67,6 @@ if (!ptr) \ return val; \ } -EVAS_SMART_SUBCLASS_NEW(_evas_object_box_type, _evas_object_box, - Evas_Object_Box_Api, Evas_Smart_Class, - evas_object_smart_clipped_class_get, NULL) - static Eina_Bool _evas_object_box_iterator_next(Evas_Object_Box_Iterator *it, void **data) { @@ -123,19 +126,11 @@ _on_child_resize(void *data, Evas *evas __UNUSED__, Evas_Object *o __UNUSED__, v static void _on_child_del(void *data, Evas *evas __UNUSED__, Evas_Object *o, void *einfo __UNUSED__) { - const Evas_Object_Box_Api *api; Evas_Object *box = data; - EVAS_OBJECT_BOX_DATA_GET(box, priv); - api = priv->api; - - if ((!api) || (!api->remove)) - { - ERR("no api->remove"); - return; - } - - if (!api->remove(box, priv, o)) + Evas_Object *ret = NULL; + eo_do(box, evas_obj_box_internal_remove(o, &ret)); + if (!ret) ERR("child removal failed"); evas_object_smart_changed(box); } @@ -158,19 +153,11 @@ _on_hints_changed(void *data __UNUSED__, Evas *evas __UNUSED__, Evas_Object *o , } static Evas_Object_Box_Option * -_evas_object_box_option_new(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child) +_evas_object_box_option_new(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, Evas_Object *child) { - Evas_Object_Box_Option *opt; - const Evas_Object_Box_Api *api; + Evas_Object_Box_Option *opt = NULL; - api = priv->api; - if ((!api) || (!api->option_new)) - { - ERR("no api->option_new"); - return NULL; - } - - opt = api->option_new(o, priv, child); + eo_do(o, evas_obj_box_internal_option_new(child, &opt)); if (!opt) { ERR("option_new failed"); @@ -192,19 +179,10 @@ _evas_object_box_child_callbacks_unregister(Evas_Object *obj) } static Evas_Object_Box_Option * -_evas_object_box_option_callbacks_register(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object_Box_Option *opt) +_evas_object_box_option_callbacks_register(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, Evas_Object_Box_Option *opt) { - const Evas_Object_Box_Api *api; Evas_Object *obj = opt->obj; - api = priv->api; - - if ((!api) || (!api->option_free)) - { - WRN("api->option_free not set (may cause memory leaks, segfaults)"); - return NULL; - } - evas_object_event_callback_add (obj, EVAS_CALLBACK_RESIZE, _on_child_resize, o); evas_object_event_callback_add @@ -215,61 +193,79 @@ _evas_object_box_option_callbacks_register(Evas_Object *o, Evas_Object_Box_Data return opt; } -static Evas_Object_Box_Option * -_evas_object_box_option_new_default(Evas_Object *o __UNUSED__, Evas_Object_Box_Data *priv __UNUSED__, Evas_Object *child) +static void +_evas_object_box_option_new_default(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) { + Evas_Object *child = va_arg(*list, Evas_Object *); + Evas_Object_Box_Option **ret = va_arg(*list, Evas_Object_Box_Option **); + *ret = NULL; + Evas_Object_Box_Option *opt; opt = (Evas_Object_Box_Option *)malloc(sizeof(*opt)); if (!opt) - return NULL; + return; opt->obj = child; - return opt; + *ret = opt; } static void -_evas_object_box_option_free_default(Evas_Object *o __UNUSED__, Evas_Object_Box_Data *priv __UNUSED__, Evas_Object_Box_Option *opt) +_evas_object_box_option_free_default(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) { + Evas_Object_Box_Option *opt = va_arg(*list, Evas_Object_Box_Option *); free(opt); } -static Evas_Object_Box_Option * -_evas_object_box_append_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child) +static void +_evas_object_box_append_default(Eo *o, void *_pd, va_list *list) { + Evas_Object *child = va_arg(*list, Evas_Object *); + Evas_Object_Box_Option **ret = va_arg(*list, Evas_Object_Box_Option **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Evas_Object_Box_Option *opt; opt = _evas_object_box_option_new(o, priv, child); if (!opt) - return NULL; + return; priv->children = eina_list_append(priv->children, opt); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_ADDED, opt); - return opt; + *ret = opt; } -static Evas_Object_Box_Option * -_evas_object_box_prepend_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child) +static void +_evas_object_box_prepend_default(Eo *o, void *_pd, va_list *list) { + Evas_Object *child = va_arg(*list, Evas_Object *); + Evas_Object_Box_Option **ret = va_arg(*list, Evas_Object_Box_Option **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Evas_Object_Box_Option *opt; opt = _evas_object_box_option_new(o, priv, child); if (!opt) - return NULL; + return; priv->children = eina_list_prepend(priv->children, opt); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_ADDED, opt); - return opt; + *ret = opt; } -static Evas_Object_Box_Option * -_evas_object_box_insert_before_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child, const Evas_Object *reference) +static void +_evas_object_box_insert_before_default(Eo *o, void *_pd, va_list *list) { + Evas_Object *child = va_arg(*list, Evas_Object *); + const Evas_Object *reference = va_arg(*list, const Evas_Object *); + Evas_Object_Box_Option **ret = va_arg(*list, Evas_Object_Box_Option **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Eina_List *l; Evas_Object_Box_Option *opt; @@ -281,22 +277,28 @@ _evas_object_box_insert_before_default(Evas_Object *o, Evas_Object_Box_Data *pri new_opt = _evas_object_box_option_new(o, priv, child); if (!new_opt) - return NULL; + return; priv->children = eina_list_prepend_relative (priv->children, new_opt, opt); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_ADDED, new_opt); - return new_opt; + *ret = new_opt; + return; } } - return NULL; + *ret = opt; } -static Evas_Object_Box_Option * -_evas_object_box_insert_after_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child, const Evas_Object *reference) +static void +_evas_object_box_insert_after_default(Eo *o, void *_pd, va_list *list) { + Evas_Object *child = va_arg(*list, Evas_Object *); + const Evas_Object *reference = va_arg(*list, const Evas_Object *); + Evas_Object_Box_Option **ret = va_arg(*list, Evas_Object_Box_Option **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Eina_List *l; Evas_Object_Box_Option *opt; @@ -308,22 +310,28 @@ _evas_object_box_insert_after_default(Evas_Object *o, Evas_Object_Box_Data *priv new_opt = _evas_object_box_option_new(o, priv, child); if (!new_opt) - return NULL; + return; priv->children = eina_list_append_relative (priv->children, new_opt, opt); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_ADDED, new_opt); - return new_opt; + *ret = new_opt; + return; } } - return NULL; + *ret = opt; } -static Evas_Object_Box_Option * -_evas_object_box_insert_at_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child, unsigned int pos) +static void +_evas_object_box_insert_at_default(Eo *o, void *_pd, va_list *list) { + Evas_Object *child = va_arg(*list, Evas_Object *); + unsigned int pos = va_arg(*list, unsigned int); + Evas_Object_Box_Option **ret = va_arg(*list, Evas_Object_Box_Option **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Eina_List *l; unsigned int i; @@ -333,12 +341,13 @@ _evas_object_box_insert_at_default(Evas_Object *o, Evas_Object_Box_Data *priv, E new_opt = _evas_object_box_option_new(o, priv, child); if (!new_opt) - return NULL; + return; priv->children = eina_list_prepend(priv->children, new_opt); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_ADDED, new_opt); - return new_opt; + *ret = new_opt; + return; } for (l = priv->children, i = 0; l; l = l->next, i++) @@ -351,34 +360,28 @@ _evas_object_box_insert_at_default(Evas_Object *o, Evas_Object_Box_Data *priv, E new_opt = _evas_object_box_option_new(o, priv, child); if (!new_opt) - return NULL; + return; priv->children = eina_list_prepend_relative (priv->children, new_opt, opt); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_ADDED, new_opt); - return new_opt; + *ret = new_opt; + return; } } - - return NULL; } -static Evas_Object * -_evas_object_box_remove_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas_Object *child) +static void +_evas_object_box_remove_default(Eo *o, void *_pd, va_list *list) { - const Evas_Object_Box_Api *api; + Evas_Object *child = va_arg(*list, Evas_Object *); + Evas_Object **ret = va_arg(*list, Evas_Object **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Evas_Object_Box_Option *opt; Eina_List *l; - api = priv->api; - - if ((!api) || (!api->option_free)) - { - ERR("api->option_free not set (may cause memory leaks, segfaults)"); - return NULL; - } - EINA_LIST_FOREACH(priv->children, l, opt) { Evas_Object *obj = opt->obj; @@ -386,76 +389,49 @@ _evas_object_box_remove_default(Evas_Object *o, Evas_Object_Box_Data *priv, Evas if (obj == child) { priv->children = eina_list_remove(priv->children, opt); - api->option_free(o, priv, opt); + eo_do(o, evas_obj_box_internal_option_free(opt)); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_REMOVED, obj); - return obj; + *ret = obj; + return; } } - - return NULL; } -static Evas_Object * -_evas_object_box_remove_at_default(Evas_Object *o, Evas_Object_Box_Data *priv, unsigned int pos) +static void +_evas_object_box_remove_at_default(Eo *o, void *_pd, va_list *list) { - const Evas_Object_Box_Api *api; + unsigned int pos = va_arg(*list, unsigned int); + Evas_Object **ret = va_arg(*list, Evas_Object **); + *ret = NULL; + Evas_Object_Box_Data *priv = _pd; Eina_List *node; Evas_Object_Box_Option *opt; Evas_Object *obj; - api = priv->api; - - if ((!api) || (!api->option_free)) - { - WRN("api->option_free not set (may cause memory leaks, segfaults)"); - return NULL; - } - node = eina_list_nth_list(priv->children, pos); if (!node) { ERR("No item to be removed at position %d", pos); - return NULL; + return; } opt = node->data; obj = opt->obj; priv->children = eina_list_remove_list(priv->children, node); - api->option_free(o, priv, opt); + eo_do(o, evas_obj_box_internal_option_free(opt)); priv->children_changed = EINA_TRUE; evas_object_smart_callback_call(o, SIG_CHILD_REMOVED, obj); - return obj; + *ret = obj; } static void -_evas_object_box_smart_add(Evas_Object *o) +_smart_add(Eo *o, void *_pd, va_list *list EINA_UNUSED) { - Evas_Object_Box_Data *priv; - - priv = evas_object_smart_data_get(o); - if (!priv) - { - const Evas_Smart *smart; - const Evas_Smart_Class *sc; - - priv = (Evas_Object_Box_Data *)calloc(1, sizeof(*priv)); - if (!priv) - { - ERR("Could not allocate object private data."); - return; - } - - smart = evas_object_smart_smart_get(o); - sc = evas_smart_class_get(smart); - priv->api = (const Evas_Object_Box_Api *)sc; - - evas_object_smart_data_set(o, priv); - } - _evas_object_box_parent_sc->add(o); - + eo_do_super(o, evas_obj_smart_add()); + Evas_Object_Box_Data *priv = _pd; evas_object_event_callback_add (o, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _on_hints_changed, o); @@ -470,19 +446,11 @@ _evas_object_box_smart_add(Evas_Object *o) } static void -_evas_object_box_smart_del(Evas_Object *o) +_smart_del(Eo *o, void *_pd, va_list *list EINA_UNUSED) { - const Evas_Object_Box_Api *api; Eina_List *l; - EVAS_OBJECT_BOX_DATA_GET(o, priv); - - api = priv->api; - if ((!api) || (!api->option_free)) - { - WRN("api->option_free not set (may cause memory leaks, segfaults)"); - return; - } + Evas_Object_Box_Data *priv = _pd; l = priv->children; while (l) @@ -490,19 +458,21 @@ _evas_object_box_smart_del(Evas_Object *o) Evas_Object_Box_Option *opt = l->data; _evas_object_box_child_callbacks_unregister(opt->obj); - api->option_free(o, priv, opt); + eo_do(o, evas_obj_box_internal_option_free(opt)); l = eina_list_remove_list(l, l); } if (priv->layout.data && priv->layout.free_data) priv->layout.free_data(priv->layout.data); - _evas_object_box_parent_sc->del(o); + eo_do_super(o, evas_obj_smart_del()); } static void -_evas_object_box_smart_resize(Evas_Object *o, Evas_Coord w, Evas_Coord h) +_smart_resize(Eo *o, void *_pd EINA_UNUSED, va_list *list) { + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); Evas_Coord ow, oh; evas_object_geometry_get(o, NULL, NULL, &ow, &oh); if ((ow == w) && (oh == h)) return; @@ -510,9 +480,9 @@ _evas_object_box_smart_resize(Evas_Object *o, Evas_Coord w, Evas_Coord h) } static void -_evas_object_box_smart_calculate(Evas_Object *o) +_smart_calculate(Eo *o, void *_pd, va_list *list EINA_UNUSED) { - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN(o, priv); + Evas_Object_Box_Data *priv = _pd; if (priv->layout.cb) { priv->layouting = 1; @@ -524,72 +494,79 @@ _evas_object_box_smart_calculate(Evas_Object *o) ERR("No layout function set for %p box.", o); } -static void -_evas_object_box_smart_set_user(Evas_Object_Box_Api *api) -{ - api->base.add = _evas_object_box_smart_add; - api->base.del = _evas_object_box_smart_del; - api->base.resize = _evas_object_box_smart_resize; - api->base.calculate = _evas_object_box_smart_calculate; - api->base.callbacks = _signals; - - api->append = _evas_object_box_append_default; - api->prepend = _evas_object_box_prepend_default; - api->insert_before = _evas_object_box_insert_before_default; - api->insert_after = _evas_object_box_insert_after_default; - api->insert_at = _evas_object_box_insert_at_default; - api->remove = _evas_object_box_remove_default; - api->remove_at = _evas_object_box_remove_at_default; - api->option_new = _evas_object_box_option_new_default; - api->option_free = _evas_object_box_option_free_default; -} - EAPI Evas_Object * evas_object_box_add(Evas *evas) { - return evas_object_smart_add(evas, _evas_object_box_smart_class_new()); + Evas_Object *obj = eo_add(MY_CLASS, evas); + eo_unref(obj); + return obj; +} + +static void +_type_check(Eo *obj, void *_pd EINA_UNUSED, va_list *list) +{ + const char *type = va_arg(*list, const char *); + Eina_Bool *type_check = va_arg(*list, Eina_Bool *); + if (0 == strcmp(type, _evas_object_box_type)) + *type_check = EINA_TRUE; + else + eo_do_super(obj, evas_obj_type_check(type, type_check)); +} + +static void +_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(obj, eo_constructor()); + eo_do(obj, + evas_obj_smart_callbacks_descriptions_set(_signals, NULL), + evas_obj_type_set(_evas_object_box_type)); } EAPI Evas_Object * evas_object_box_add_to(Evas_Object *parent) { - Evas *evas; - Evas_Object *o; - - evas = evas_object_evas_get(parent); - o = evas_object_box_add(evas); - evas_object_smart_member_add(o, parent); + Evas_Object *o = NULL; + eo_do(parent, evas_obj_box_add_to(&o)); return o; } -EAPI void -evas_object_box_smart_set(Evas_Object_Box_Api *api) +static void +_box_add_to(Eo *parent, void *_pd EINA_UNUSED, va_list *list) { - if (!api) - return; - _evas_object_box_smart_set(api); + Evas *evas; + Evas_Object **o = va_arg(*list, Evas_Object **); + + evas = evas_object_evas_get(parent); + *o = evas_object_box_add(evas); + evas_object_smart_member_add(*o, parent); +} + +EAPI void +evas_object_box_smart_set(Evas_Object_Box_Api *api EINA_UNUSED) +{ + return; } EAPI const Evas_Object_Box_Api * evas_object_box_smart_class_get(void) { - static Evas_Object_Box_Api _sc = - EVAS_OBJECT_BOX_API_INIT_NAME_VERSION(_evas_object_box_type); - static const Evas_Object_Box_Api *class = NULL; - - if (class) - return class; - - evas_object_box_smart_set(&_sc); - class = &_sc; - - return class; + return NULL; } EAPI void evas_object_box_layout_set(Evas_Object *o, Evas_Object_Box_Layout cb, const void *data, void (*free_data)(void *data)) { - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_box_layout_set(cb, data, free_data)); +} + +static void +_box_layout_set(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Data *priv = _pd; + + Evas_Object_Box_Layout cb = va_arg(*list, Evas_Object_Box_Layout); + const void *data = va_arg(*list, const void *); + void (*free_data)(void *data) = va_arg(*list, void (*)(void *data)); if ((priv->layout.cb == cb) && (priv->layout.data == data) && (priv->layout.free_data == free_data)) @@ -746,8 +723,16 @@ _evas_object_box_layout_horizontal_weight_apply(Evas_Object_Box_Data *priv, Evas } EAPI void -evas_object_box_layout_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_horizontal()); +} + +static void +_box_layout_horizontal(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int pad_inc = 0, sub_pixel = 0; int req_w, global_pad, remaining, top_h = 0; double weight_total = 0.0; @@ -904,8 +889,16 @@ _evas_object_box_layout_vertical_weight_apply(Evas_Object_Box_Data *priv, Evas_O } EAPI void -evas_object_box_layout_vertical(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_vertical(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_vertical()); +} + +static void +_box_layout_vertical(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int pad_inc = 0, sub_pixel = 0; int req_h, global_pad, remaining, top_w = 0; double weight_total = 0.0; @@ -1009,8 +1002,16 @@ evas_object_box_layout_vertical(Evas_Object *o, Evas_Object_Box_Data *priv, void } EAPI void -evas_object_box_layout_homogeneous_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_homogeneous_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_homogeneous_horizontal()); +} + +static void +_box_layout_homogeneous_horizontal(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int cell_sz, share, inc; int sub_pixel = 0; int x, y, w, h; @@ -1070,8 +1071,16 @@ evas_object_box_layout_homogeneous_horizontal(Evas_Object *o, Evas_Object_Box_Da } EAPI void -evas_object_box_layout_homogeneous_vertical(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_homogeneous_vertical(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_homogeneous_vertical()); +} + +static void +_box_layout_homogeneous_vertical(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int cell_sz, share, inc; int sub_pixel = 0; int x, y, w, h; @@ -1130,8 +1139,16 @@ evas_object_box_layout_homogeneous_vertical(Evas_Object *o, Evas_Object_Box_Data } EAPI void -evas_object_box_layout_homogeneous_max_size_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_homogeneous_max_size_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_homogeneous_max_size_horizontal()); +} + +static void +_box_layout_homogeneous_max_size_horizontal(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int remaining, global_pad, pad_inc = 0, sub_pixel = 0; int cell_sz = 0; int x, y, w, h; @@ -1214,8 +1231,16 @@ evas_object_box_layout_homogeneous_max_size_horizontal(Evas_Object *o, Evas_Obje } EAPI void -evas_object_box_layout_homogeneous_max_size_vertical(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_homogeneous_max_size_vertical(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_homogeneous_max_size_vertical()); +} + +static void +_box_layout_homogeneous_max_size_vertical(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int remaining, global_pad, pad_inc = 0, sub_pixel = 0; int cell_sz = 0; int x, y, w, h; @@ -1362,8 +1387,16 @@ _evas_object_box_layout_flow_horizontal_row_info_collect(Evas_Object_Box_Data *p } EAPI void -evas_object_box_layout_flow_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_flow_horizontal(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_flow_horizontal()); +} + +static void +_box_layout_flow_horizontal(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int n_children; int r, row_count = 0; int min_w = 0, min_h = 0; @@ -1542,8 +1575,16 @@ _evas_object_box_layout_flow_vertical_col_info_collect(Evas_Object_Box_Data *pri } EAPI void -evas_object_box_layout_flow_vertical(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_flow_vertical(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_flow_vertical()); +} + +static void +_box_layout_flow_vertical(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + int n_children; int c, col_count; int min_w = 0, min_h = 0; @@ -1657,8 +1698,16 @@ evas_object_box_layout_flow_vertical(Evas_Object *o, Evas_Object_Box_Data *priv, } EAPI void -evas_object_box_layout_stack(Evas_Object *o, Evas_Object_Box_Data *priv, void *data __UNUSED__) +evas_object_box_layout_stack(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUSED, void *data EINA_UNUSED) { + eo_do(o, evas_obj_box_layout_stack()); +} + +static void +_box_layout_stack(Eo *o, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Box_Data *priv = _pd; + Eina_List *l; Evas_Coord ox, oy, ow, oh; Evas_Coord top_w = 0, top_h = 0; @@ -1707,7 +1756,16 @@ evas_object_box_layout_stack(Evas_Object *o, Evas_Object_Box_Data *priv, void *d EAPI void evas_object_box_align_set(Evas_Object *o, double horizontal, double vertical) { - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_box_align_set(horizontal, vertical)); +} + +static void +_box_align_set(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Data *priv = _pd; + double horizontal = va_arg(*list, double); + double vertical = va_arg(*list, double); + if (priv->align.h == horizontal && priv->align.v == vertical) return; priv->align.h = horizontal; @@ -1718,7 +1776,16 @@ evas_object_box_align_set(Evas_Object *o, double horizontal, double vertical) EAPI void evas_object_box_align_get(const Evas_Object *o, double *horizontal, double *vertical) { - EVAS_OBJECT_BOX_DATA_GET(o, priv); + eo_do((Eo *)o, evas_obj_box_align_get(horizontal, vertical)); +} + +static void +_box_align_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Box_Data *priv = _pd; + double *horizontal = va_arg(*list, double *); + double *vertical = va_arg(*list, double *); + if (priv) { if (horizontal) *horizontal = priv->align.h; @@ -1734,7 +1801,17 @@ evas_object_box_align_get(const Evas_Object *o, double *horizontal, double *vert EAPI void evas_object_box_padding_set(Evas_Object *o, Evas_Coord horizontal, Evas_Coord vertical) { - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_box_padding_set(horizontal, vertical)); +} + +static void +_box_padding_set(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Data *priv = _pd; + + Evas_Coord horizontal = va_arg(*list, Evas_Coord); + Evas_Coord vertical = va_arg(*list, Evas_Coord); + if (priv->pad.h == horizontal && priv->pad.v == vertical) return; priv->pad.h = horizontal; @@ -1745,7 +1822,17 @@ evas_object_box_padding_set(Evas_Object *o, Evas_Coord horizontal, Evas_Coord ve EAPI void evas_object_box_padding_get(const Evas_Object *o, Evas_Coord *horizontal, Evas_Coord *vertical) { - EVAS_OBJECT_BOX_DATA_GET(o, priv); + eo_do((Eo *)o, evas_obj_box_padding_get(horizontal, vertical)); +} + +static void +_box_padding_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Box_Data *priv = _pd; + + Evas_Coord *horizontal = va_arg(*list, Evas_Coord *); + Evas_Coord *vertical = va_arg(*list, Evas_Coord *); + if (priv) { if (horizontal) *horizontal = priv->pad.h; @@ -1761,200 +1848,241 @@ evas_object_box_padding_get(const Evas_Object *o, Evas_Coord *horizontal, Evas_C EAPI Evas_Object_Box_Option * evas_object_box_append(Evas_Object *o, Evas_Object *child) { - Evas_Object_Box_Option *opt; - const Evas_Object_Box_Api *api; + Evas_Object_Box_Option *option = NULL; + eo_do(o, evas_obj_box_append(child, &option)); + return option; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); +static void +_box_append(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Option *opt = NULL; + + Evas_Object_Box_Data *priv = _pd; + Evas_Object *child = va_arg(*list, Evas_Object *); + Evas_Object_Box_Option **option = va_arg(*list, Evas_Object_Box_Option **); + if (option) *option = NULL; if (!child) - return NULL; + return; - api = priv->api; - if ((!api) || (!api->append)) - return NULL; - - opt = api->append(o, priv, child); + eo_do(o, evas_obj_box_internal_append(child, &opt)); if (opt) { evas_object_smart_member_add(child, o); evas_object_smart_changed(o); - return _evas_object_box_option_callbacks_register(o, priv, opt); + if (option) *option = _evas_object_box_option_callbacks_register(o, priv, opt); + return; } - - return NULL; } EAPI Evas_Object_Box_Option * evas_object_box_prepend(Evas_Object *o, Evas_Object *child) { - Evas_Object_Box_Option *opt; - const Evas_Object_Box_Api *api; + Evas_Object_Box_Option *option = NULL; + eo_do(o, evas_obj_box_prepend(child, &option)); + return option; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); +static void +_box_prepend(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Option *opt = NULL; + + Evas_Object_Box_Data *priv = _pd; + Evas_Object *child = va_arg(*list, Evas_Object *); + Evas_Object_Box_Option **option = va_arg(*list, Evas_Object_Box_Option **); + if (option) *option = NULL; if (!child) - return NULL; + return; - api = priv->api; - if ((!api) || (!api->prepend)) - return NULL; - - opt = api->prepend(o, priv, child); + eo_do(o, evas_obj_box_internal_prepend(child, &opt)); if (opt) { evas_object_smart_member_add(child, o); evas_object_smart_changed(o); - return _evas_object_box_option_callbacks_register(o, priv, opt); + if (option) *option = _evas_object_box_option_callbacks_register(o, priv, opt); + return; } - - return NULL; } EAPI Evas_Object_Box_Option * evas_object_box_insert_before(Evas_Object *o, Evas_Object *child, const Evas_Object *reference) { - Evas_Object_Box_Option *opt; - const Evas_Object_Box_Api *api; + Evas_Object_Box_Option *option = NULL; + eo_do(o, evas_obj_box_insert_before(child, reference, &option)); + return option; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); +static void +_box_insert_before(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Option *opt = NULL; + + Evas_Object_Box_Data *priv = _pd; + Evas_Object *child = va_arg(*list, Evas_Object *); + const Evas_Object *reference = va_arg(*list, const Evas_Object *); + Evas_Object_Box_Option **option = va_arg(*list, Evas_Object_Box_Option **); + if (option) *option = NULL; if (!child) - return NULL; + return; - api = priv->api; - if ((!api) || (!api->insert_before)) - return NULL; - - opt = api->insert_before(o, priv, child, reference); + eo_do(o, evas_obj_box_internal_insert_before(child, reference, &opt)); if (opt) { evas_object_smart_member_add(child, o); evas_object_smart_changed(o); - return _evas_object_box_option_callbacks_register(o, priv, opt); + if (option) *option = _evas_object_box_option_callbacks_register(o, priv, opt); + return; } - - return NULL; } EAPI Evas_Object_Box_Option * evas_object_box_insert_after(Evas_Object *o, Evas_Object *child, const Evas_Object *reference) { - Evas_Object_Box_Option *opt; - const Evas_Object_Box_Api *api; + Evas_Object_Box_Option *option = NULL; + eo_do(o, evas_obj_box_insert_after(child, reference, &option)); + return option; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, NULL); +static void +_box_insert_after(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Option *opt = NULL; + + Evas_Object_Box_Data *priv = _pd; + Evas_Object *child = va_arg(*list, Evas_Object *); + const Evas_Object *reference = va_arg(*list, const Evas_Object *); + Evas_Object_Box_Option **option = va_arg(*list, Evas_Object_Box_Option **); + if (option) *option = NULL; if (!child) - return NULL; + return; - api = priv->api; - if ((!api) || (!api->insert_after)) - return NULL; - - opt = api->insert_after(o, priv, child, reference); + eo_do(o, evas_obj_box_internal_insert_after(child, reference, &opt)); if (opt) { evas_object_smart_member_add(child, o); evas_object_smart_changed(o); - return _evas_object_box_option_callbacks_register(o, priv, opt); + if (option) *option = _evas_object_box_option_callbacks_register(o, priv, opt); + return; } - - return NULL; } EAPI Evas_Object_Box_Option * evas_object_box_insert_at(Evas_Object *o, Evas_Object *child, unsigned int pos) { - Evas_Object_Box_Option *opt; - const Evas_Object_Box_Api *api; + Evas_Object_Box_Option *option = NULL; + eo_do(o, evas_obj_box_insert_at(child, pos, &option)); + return option; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); +static void +_box_insert_at(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Option *opt = NULL; + + Evas_Object_Box_Data *priv = _pd; + Evas_Object *child = va_arg(*list, Evas_Object *); + unsigned int pos = va_arg(*list, unsigned int); + Evas_Object_Box_Option **option = va_arg(*list, Evas_Object_Box_Option **); + if (option) *option = NULL; if (!child) - return NULL; + return; - api = priv->api; - if ((!api) || (!api->insert_at)) - return NULL; - - opt = api->insert_at(o, priv, child, pos); + eo_do(o, evas_obj_box_internal_insert_at(child, pos, &opt)); if (opt) { evas_object_smart_member_add(child, o); evas_object_smart_changed(o); - return _evas_object_box_option_callbacks_register(o, priv, opt); + if (option) *option = _evas_object_box_option_callbacks_register(o, priv, opt); + return; } - - return NULL; } EAPI Eina_Bool evas_object_box_remove(Evas_Object *o, Evas_Object *child) { - const Evas_Object_Box_Api *api; - Evas_Object *obj; + Eina_Bool result = EINA_FALSE; + eo_do(o, evas_obj_box_remove(child, &result)); + return result; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); - if (!child) return EINA_FALSE; +static void +_box_remove(Eo *o, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object *child = va_arg(*list, Evas_Object *); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = EINA_FALSE; + Evas_Object *obj = NULL; - api = priv->api; - if ((!api) || (!api->remove)) - return 0; - - obj = api->remove(o, priv, child); + eo_do(o, evas_obj_box_internal_remove(child, &obj)); if (obj) { _evas_object_box_child_callbacks_unregister(obj); evas_object_smart_member_del(obj); evas_object_smart_changed(o); - return EINA_TRUE; + if (result) *result = EINA_TRUE; + return; } - - return EINA_FALSE; } EAPI Eina_Bool evas_object_box_remove_at(Evas_Object *o, unsigned int pos) { - const Evas_Object_Box_Api *api; - Evas_Object *obj; + Eina_Bool result = EINA_FALSE; + eo_do(o, evas_obj_box_remove_at(pos, &result)); + return result; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); - api = priv->api; - if ((!api) || (!api->remove_at)) return EINA_FALSE; +static void +_box_remove_at(Eo *o, void *_pd EINA_UNUSED, va_list *list) +{ + unsigned int pos = va_arg(*list, unsigned int); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = EINA_FALSE; + Evas_Object *obj = NULL; - obj = api->remove_at(o, priv, pos); + eo_do(o, evas_obj_box_internal_remove_at(pos, &obj)); if (obj) { _evas_object_box_child_callbacks_unregister(obj); evas_object_smart_member_del(obj); evas_object_smart_changed(o); - return EINA_TRUE; + if (result) *result = EINA_TRUE; + return; } - - return EINA_FALSE; } EAPI Eina_Bool evas_object_box_remove_all(Evas_Object *o, Eina_Bool clear) { - const Evas_Object_Box_Api *api; + Eina_Bool result = EINA_FALSE; + eo_do(o, evas_obj_box_remove_all(clear, &result)); + return result; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); - - api = priv->api; - if ((!api) || (!api->remove)) return EINA_FALSE; +static void +_box_remove_all(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Box_Data *priv = _pd; + Eina_Bool clear = va_arg(*list, int); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = EINA_FALSE; evas_object_smart_changed(o); while (priv->children) { Evas_Object_Box_Option *opt = priv->children->data; - Evas_Object *obj; + Evas_Object *obj = NULL; - obj = api->remove(o, priv, opt->obj); + eo_do(o, evas_obj_box_internal_remove(opt->obj, &obj)); if (obj) { _evas_object_box_child_callbacks_unregister(obj); @@ -1962,23 +2090,33 @@ evas_object_box_remove_all(Evas_Object *o, Eina_Bool clear) if (clear) evas_object_del(obj); } - else return EINA_FALSE; + else return; } - return EINA_TRUE; + if (result) *result = EINA_TRUE; } EAPI Eina_Iterator * evas_object_box_iterator_new(const Evas_Object *o) { + Eina_Iterator *itr = NULL; + eo_do((Eo *)o, evas_obj_box_iterator_new(&itr)); + return itr; +} + +static void +_box_iterator_new(Eo *o, void *_pd, va_list *list) +{ + const Evas_Object_Box_Data *priv = _pd; + + Eina_Iterator **itr_ret = va_arg(*list, Eina_Iterator **); Evas_Object_Box_Iterator *it; + *itr_ret = NULL; - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, NULL); - - if (!priv->children) return NULL; + if (!priv->children) return; it = calloc(1, sizeof(Evas_Object_Box_Iterator)); - if (!it) return NULL; + if (!it) return; EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR); @@ -1989,20 +2127,30 @@ evas_object_box_iterator_new(const Evas_Object *o) it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_evas_object_box_iterator_get_container); it->iterator.free = FUNC_ITERATOR_FREE(_evas_object_box_iterator_free); - return &it->iterator; + *itr_ret = &it->iterator; } EAPI Eina_Accessor * evas_object_box_accessor_new(const Evas_Object *o) { + Eina_Accessor * accessor = NULL; + eo_do((Eo *)o, evas_obj_box_accessor_new(&accessor)); + return accessor; +} + +static void +_box_accessor_new(Eo *o, void *_pd, va_list *list) +{ + const Evas_Object_Box_Data *priv = _pd; + + Eina_Accessor **accessor = va_arg(*list, Eina_Accessor **); + *accessor = NULL; Evas_Object_Box_Accessor *it; - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, NULL); - - if (!priv->children) return NULL; - + if (!priv->children) return; + it = calloc(1, sizeof(Evas_Object_Box_Accessor)); - if (!it) return NULL; + if (!it) return; EINA_MAGIC_SET(&it->accessor, EINA_MAGIC_ACCESSOR); @@ -2013,7 +2161,7 @@ evas_object_box_accessor_new(const Evas_Object *o) it->accessor.get_container = FUNC_ACCESSOR_GET_CONTAINER(_evas_object_box_accessor_get_container); it->accessor.free = FUNC_ACCESSOR_FREE(_evas_object_box_accessor_free); - return &it->accessor; + *accessor = &it->accessor; } EAPI Eina_List * @@ -2033,35 +2181,36 @@ evas_object_box_children_get(const Evas_Object *o) EAPI const char * evas_object_box_option_property_name_get(const Evas_Object *o, int property) { - const Evas_Object_Box_Api *api; + const char *name = NULL; + eo_do((Eo *)o, evas_obj_box_option_property_name_get(property, &name)); + return name; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, NULL); - - if (property < 0) - return NULL; - - api = priv->api; - if ((!api) || (!api->property_name_get)) - return NULL; - - return api->property_name_get(o, property); +static void +_box_option_property_name_get(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + va_arg(*list, int); + const char **name = va_arg(*list, const char **); + *name = NULL; } EAPI int evas_object_box_option_property_id_get(const Evas_Object *o, const char *name) { - const Evas_Object_Box_Api *api; + int id = 0; + eo_do((Eo *)o, evas_obj_box_option_property_id_get(name, &id)); + return id; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, -1); +static void +_box_option_property_id_get(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + const char *name = va_arg(*list, const char *); + int *id = va_arg(*list, int *); + *id = -1; if (!name) - return -1; - - api = priv->api; - if ((!api) || (!api->property_id_get)) - return -1; - - return api->property_id_get(o, name); + return; } EAPI Eina_Bool @@ -2081,21 +2230,19 @@ evas_object_box_option_property_set(Evas_Object *o, Evas_Object_Box_Option *opt, EAPI Eina_Bool evas_object_box_option_property_vset(Evas_Object *o, Evas_Object_Box_Option *opt, int property, va_list args) { - const Evas_Object_Box_Api *api; + Eina_Bool ret = EINA_FALSE; + eo_do(o, evas_obj_box_option_property_vset(opt, property, args, &ret)); + return ret; +} - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); - - if (!opt) return EINA_FALSE; - - api = priv->api; - if ((!api) || (!api->property_set)) - return EINA_FALSE; - - if (!api->property_set(o, opt, property, args)) - return EINA_FALSE; - - evas_object_smart_changed(o); - return EINA_TRUE; +static void +_box_option_property_vset(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + va_arg(*list, Evas_Object_Box_Option *); + va_arg(*list, int); + va_arg(*list, va_list); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; } EAPI Eina_Bool @@ -2114,15 +2261,140 @@ evas_object_box_option_property_get(const Evas_Object *o, Evas_Object_Box_Option EAPI Eina_Bool evas_object_box_option_property_vget(const Evas_Object *o, Evas_Object_Box_Option *opt, int property, va_list args) { - const Evas_Object_Box_Api *api; - - EVAS_OBJECT_BOX_DATA_GET_OR_RETURN_VAL(o, priv, 0); - - if (!opt) return EINA_FALSE; - - api = priv->api; - if ((!api) || (!api->property_get)) - return EINA_FALSE; - - return api->property_get(o, opt, property, args); + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)o, evas_obj_box_option_property_vget(opt, property, args, &ret)); + return ret; } + +static void +_box_option_property_vget(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + va_arg(*list, Evas_Object_Box_Option *); + va_arg(*list, int); + va_arg(*list, va_list); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + *ret = EINA_FALSE; +} + +static void +_smart_data_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + void **data = va_arg(*list, void **); + *data = (void *)_pd; +} + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_CHECK), _type_check), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_DATA_GET), _smart_data_get), + + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _smart_add), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _smart_del), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _smart_resize), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALCULATE), _smart_calculate), + + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_APPEND), _evas_object_box_append_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_PREPEND), _evas_object_box_prepend_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_BEFORE), _evas_object_box_insert_before_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AFTER), _evas_object_box_insert_after_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AT), _evas_object_box_insert_at_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE), _evas_object_box_remove_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE_AT), _evas_object_box_remove_at_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_NEW), _evas_object_box_option_new_default), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_FREE), _evas_object_box_option_free_default), + + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ADD_TO), _box_add_to), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_SET), _box_layout_set), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HORIZONTAL), _box_layout_horizontal), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_VERTICAL), _box_layout_vertical), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_HORIZONTAL), _box_layout_homogeneous_horizontal), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_VERTICAL), _box_layout_homogeneous_vertical), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_HORIZONTAL), _box_layout_homogeneous_max_size_horizontal), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_VERTICAL), _box_layout_homogeneous_max_size_vertical), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_HORIZONTAL), _box_layout_flow_horizontal), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_VERTICAL), _box_layout_flow_vertical), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_LAYOUT_STACK), _box_layout_stack), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ALIGN_SET), _box_align_set), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ALIGN_GET), _box_align_get), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_PADDING_SET), _box_padding_set), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_PADDING_GET), _box_padding_get), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_APPEND), _box_append), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_PREPEND), _box_prepend), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INSERT_BEFORE), _box_insert_before), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INSERT_AFTER), _box_insert_after), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_INSERT_AT), _box_insert_at), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_REMOVE), _box_remove), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_REMOVE_AT), _box_remove_at), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_REMOVE_ALL), _box_remove_all), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ITERATOR_NEW), _box_iterator_new), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_ACCESSOR_NEW), _box_accessor_new), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_NAME_GET), _box_option_property_name_get), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_ID_GET), _box_option_property_id_get), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VSET), _box_option_property_vset), + EO_OP_FUNC(EVAS_OBJ_BOX_ID(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VGET), _box_option_property_vget), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_APPEND, "Append a new child object to the given box object. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_PREPEND, "Prepend a new child object to the given box object. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_BEFORE, "Insert a new child object before another existing one Can be overrided.."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AFTER, "Insert a new child object after another existing one. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_INSERT_AT, "Insert a new child object at a given position. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE, "Remove a given object from a box object, unparenting it again. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_REMOVE_AT, "Remove an object, bound to a given position in a box object. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_NEW, "Create a new box option. Can be overrided."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INTERNAL_OPTION_FREE, "Free a box option. Can be overrided."), + + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_ADD_TO, "Add a new box as a child of a given smart object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_SET, "Set a new layouting function to a given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HORIZONTAL, "Layout function which sets the box to a (basic) horizontal box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_VERTICAL, "Layout function which sets the box to a (basic) vertical box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_HORIZONTAL, "Layout function which sets the box to a homogeneous horizontal box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_VERTICAL, "Layout function which sets the box to a homogeneous vertical box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_HORIZONTAL, "Layout function which sets the box to a maximum size, homogeneous horizontal box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_HOMOGENEOUS_MAX_SIZE_VERTICAL, "Layout function which sets the box to a maximum size, homogeneous vertical box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_HORIZONTAL, "Layout function which sets the box to a flow horizontal box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_FLOW_VERTICAL, "Layout function which sets the box to a flow vertical box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_LAYOUT_STACK, "Layout function which sets the box to a stacking box."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_ALIGN_SET, "Set the alignment of the whole bounding box of contents."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_ALIGN_GET, "Get the alignment of the whole bounding box of contents."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_PADDING_SET, "Set the (space) padding between cells set for a given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_PADDING_GET, "Get the (space) padding between cells set for a given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_APPEND, "Append a new child object to the given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_PREPEND, "Prepend a new child object to the given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INSERT_BEFORE, "Insert a new child object before another existing one."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INSERT_AFTER, "Insert a new child object after another existing one."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_INSERT_AT, "Insert a new child object at a given position."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_REMOVE, "Remove a given object from a box object, unparenting it again."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_REMOVE_AT, "Remove an object, bound to a given position in a box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_REMOVE_ALL, "Remove all child objects from a box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_ITERATOR_NEW, "Get an iterator to walk the list of children of a given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_ACCESSOR_NEW, "Get an accessor (a structure providing random items access) to the list of children of a given box object."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_NAME_GET, "Get the name of the property of the child elements of the box with specific id."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_ID_GET, "Get the numerical identifier of the property of the child elements of the box which have a specific name."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VSET, "Set a property value (by its given numerical identifier), on a given box child element."), + EO_OP_DESCRIPTION(EVAS_OBJ_BOX_SUB_ID_OPTION_PROPERTY_VGET, "Get a property's value (by its given numerical identifier), on a given box child element."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Box", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_BOX_BASE_ID, op_desc, EVAS_OBJ_BOX_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Box_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_box_class_get, &class_desc, EVAS_OBJ_SMART_CLIPPED_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_grid.c b/legacy/evas/src/lib/canvas/evas_object_grid.c index c070b9cee9..7a440cb262 100644 --- a/legacy/evas/src/lib/canvas/evas_object_grid.c +++ b/legacy/evas/src/lib/canvas/evas_object_grid.c @@ -1,6 +1,13 @@ #include "evas_common.h" +#include "evas_private.h" #include +#include + +EAPI Eo_Op EVAS_OBJ_GRID_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_GRID_CLASS + typedef struct _Evas_Object_Grid_Data Evas_Object_Grid_Data; typedef struct _Evas_Object_Grid_Option Evas_Object_Grid_Option; typedef struct _Evas_Object_Grid_Iterator Evas_Object_Grid_Iterator; @@ -40,7 +47,7 @@ struct _Evas_Object_Grid_Accessor }; #define EVAS_OBJECT_GRID_DATA_GET(o, ptr) \ - Evas_Object_Grid_Data *ptr = evas_object_smart_data_get(o) + Evas_Object_Grid_Data *ptr = eo_data_get(o, MY_CLASS) #define EVAS_OBJECT_GRID_DATA_GET_OR_RETURN(o, ptr) \ EVAS_OBJECT_GRID_DATA_GET(o, ptr); \ @@ -131,7 +138,7 @@ _evas_object_grid_option_del(Evas_Object *o) } static void -_on_child_del(void *data, Evas *evas __UNUSED__, Evas_Object *child, void *einfo __UNUSED__) +_on_child_del(void *data, Evas *evas EINA_UNUSED, Evas_Object *child, void *einfo EINA_UNUSED) { Evas_Object *grid = data; evas_object_grid_unpack(grid, child); @@ -158,7 +165,14 @@ EVAS_SMART_SUBCLASS_NEW("Evas_Object_Grid", _evas_object_grid, static void _evas_object_grid_smart_add(Evas_Object *o) { - EVAS_SMART_DATA_ALLOC(o, Evas_Object_Grid_Data) + Evas_Object_Grid_Data *priv; + + priv = evas_object_smart_data_get(o); + if (!priv) + { + priv = eo_data_get(o, MY_CLASS); + evas_object_smart_data_set(o, priv); + } priv->size.w = 100; priv->size.h = 100; @@ -238,25 +252,51 @@ _evas_object_grid_smart_set_user(Evas_Smart_Class *sc) EAPI Evas_Object * evas_object_grid_add(Evas *evas) { - return evas_object_smart_add(evas, _evas_object_grid_smart_class_new()); + Evas_Object *obj = eo_add(MY_CLASS, evas); + eo_unref(obj); + return obj; +} + +static void +_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(obj, eo_constructor()); + eo_do(obj, evas_obj_smart_attach(_evas_object_grid_smart_class_new())); + +// return evas_object_smart_add(evas, _evas_object_grid_smart_class_new()); } EAPI Evas_Object * evas_object_grid_add_to(Evas_Object *parent) { - Evas *evas; - Evas_Object *o; - - evas = evas_object_evas_get(parent); - o = evas_object_grid_add(evas); - evas_object_smart_member_add(o, parent); + Evas_Object *o = NULL; + eo_do(parent, evas_obj_grid_add_to(&o)); return o; } +static void +_add_to(Eo *parent, void *_pd EINA_UNUSED, va_list *list) +{ + Evas *evas; + Evas_Object **ret = va_arg(*list, Evas_Object **); + evas = evas_object_evas_get(parent); + *ret = evas_object_grid_add(evas); + evas_object_smart_member_add(*ret, parent); +} + EAPI void evas_object_grid_size_set(Evas_Object *o, int w, int h) { - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_grid_size_set(w, h)); +} + +static void +_size_set(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Grid_Data *priv = _pd; + int w = va_arg(*list, int); + int h = va_arg(*list, int); + if ((priv->size.w == w) && (priv->size.h == h)) return; priv->size.w = w; priv->size.h = h; @@ -266,20 +306,42 @@ evas_object_grid_size_set(Evas_Object *o, int w, int h) EAPI void evas_object_grid_size_get(const Evas_Object *o, int *w, int *h) { - if (w) *w = 0; - if (h) *h = 0; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN(o, priv); + eo_do((Eo *)o, evas_obj_grid_size_get(w, h)); +} + +static void +_size_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Grid_Data *priv = _pd; + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); if (w) *w = priv->size.w; if (h) *h = priv->size.h; } EAPI Eina_Bool evas_object_grid_pack(Evas_Object *o, Evas_Object *child, int x, int y, int w, int h) +{ + Eina_Bool ret = EINA_FALSE; + eo_do(o, evas_obj_grid_pack(child, x, y, w, h, &ret)); + return ret; +} + +static void +_pack(Eo *o, void *_pd, va_list *list) { Evas_Object_Grid_Option *opt; Eina_Bool newobj = EINA_FALSE; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(o, priv, 0); + Evas_Object_Grid_Data *priv = _pd; + + Evas_Object *child = va_arg(*list, Evas_Object *); + int x = va_arg(*list, int); + int y = va_arg(*list, int); + int w = va_arg(*list, int); + int h = va_arg(*list, int); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; opt = _evas_object_grid_option_get(child); if (!opt) @@ -288,7 +350,7 @@ evas_object_grid_pack(Evas_Object *o, Evas_Object *child, int x, int y, int w, i if (!opt) { ERR("could not allocate grid option data."); - return EINA_FALSE; + return; } newobj = EINA_TRUE; } @@ -309,7 +371,7 @@ evas_object_grid_pack(Evas_Object *o, Evas_Object *child, int x, int y, int w, i } // FIXME: we could keep a changed list evas_object_smart_changed(o); - return EINA_TRUE; + if (ret) *ret = EINA_TRUE; } static void @@ -321,37 +383,56 @@ _evas_object_grid_remove_opt(Evas_Object_Grid_Data *priv, Evas_Object_Grid_Optio EAPI Eina_Bool evas_object_grid_unpack(Evas_Object *o, Evas_Object *child) +{ + Eina_Bool ret = EINA_FALSE; + eo_do(o, evas_obj_grid_unpack(child, &ret)); + return ret; +} + +static void +_unpack(Eo *o, void *_pd, va_list *list) { Evas_Object_Grid_Option *opt; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(o, priv, 0); + Evas_Object_Grid_Data *priv = _pd; + + Evas_Object *child = va_arg(*list, Evas_Object *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; if (o != evas_object_smart_parent_get(child)) { ERR("cannot unpack child from incorrect grid!"); - return EINA_FALSE; + return; } opt = _evas_object_grid_option_del(child); if (!opt) { ERR("cannot unpack child with no packing option!"); - return EINA_FALSE; + return; } _evas_object_grid_child_disconnect(o, child); _evas_object_grid_remove_opt(priv, opt); evas_object_smart_member_del(child); free(opt); - return EINA_TRUE; + if (ret) *ret = EINA_TRUE; } EAPI void evas_object_grid_clear(Evas_Object *o, Eina_Bool clear) +{ + eo_do(o, evas_obj_grid_clear(clear)); +} + +static void +_clear(Eo *o, void *_pd, va_list *list) { Evas_Object_Grid_Option *opt; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN(o, priv); + Evas_Object_Grid_Data *priv = _pd; + Eina_Bool clear = va_arg(*list, int); EINA_LIST_FREE(priv->children, opt) { @@ -367,33 +448,68 @@ evas_object_grid_clear(Evas_Object *o, Eina_Bool clear) EAPI Eina_Bool evas_object_grid_pack_get(const Evas_Object *o, Evas_Object *child, int *x, int *y, int *w, int *h) { + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)o, evas_obj_grid_pack_get(child, x, y, w, h, &ret)); + return ret; +} + +static void +_pack_get(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object *child = va_arg(*list, Evas_Object *); + int *x = va_arg(*list, int *); + int *y = va_arg(*list, int *); + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + Evas_Object_Grid_Option *opt; if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(o, priv, 0); opt = _evas_object_grid_option_get(child); - if (!opt) return 0; + if (!opt) + { + *ret = 0; + return; + } if (x) *x = opt->x; if (y) *y = opt->y; if (w) *w = opt->w; if (h) *h = opt->h; - return 1; + *ret = 1; } EAPI Eina_Iterator * evas_object_grid_iterator_new(const Evas_Object *o) { + Eina_Iterator *ret = NULL; + eo_do((Eo *)o, evas_obj_grid_iterator_new(&ret)); + return ret; +} + +static void +_iterator_new(Eo *o, void *_pd, va_list *list) +{ + Eina_Iterator **ret = va_arg(*list, Eina_Iterator **); Evas_Object_Grid_Iterator *it; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(o, priv, NULL); + const Evas_Object_Grid_Data *priv = _pd; - if (!priv->children) return NULL; + if (!priv->children) + { + *ret = NULL; + return; + } it = calloc(1, sizeof(Evas_Object_Grid_Iterator)); - if (!it) return NULL; + if (!it) + { + *ret = NULL; + return; + } EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR); @@ -404,20 +520,37 @@ evas_object_grid_iterator_new(const Evas_Object *o) it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_evas_object_grid_iterator_get_container); it->iterator.free = FUNC_ITERATOR_FREE(_evas_object_grid_iterator_free); - return &it->iterator; + *ret = &it->iterator; } EAPI Eina_Accessor * evas_object_grid_accessor_new(const Evas_Object *o) { + Eina_Accessor *ret = NULL; + eo_do((Eo *)o, evas_obj_grid_accessor_new(&ret)); + return ret; +} + +static void +_accessor_new(Eo *o, void *_pd, va_list *list) +{ + Eina_Accessor **ret = va_arg(*list, Eina_Accessor **); Evas_Object_Grid_Accessor *it; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(o, priv, NULL); + const Evas_Object_Grid_Data *priv = _pd; - if (!priv->children) return NULL; + if (!priv->children) + { + *ret = NULL; + return; + } it = calloc(1, sizeof(Evas_Object_Grid_Accessor)); - if (!it) return NULL; + if (!it) + { + *ret = NULL; + return; + } EINA_MAGIC_SET(&it->accessor, EINA_MAGIC_ACCESSOR); @@ -428,38 +561,117 @@ evas_object_grid_accessor_new(const Evas_Object *o) it->accessor.get_container = FUNC_ACCESSOR_GET_CONTAINER(_evas_object_grid_accessor_get_container); it->accessor.free = FUNC_ACCESSOR_FREE(_evas_object_grid_accessor_free); - return &it->accessor; + *ret = &it->accessor; } EAPI Eina_List * evas_object_grid_children_get(const Evas_Object *o) { + Eina_List *ret = NULL; + eo_do((Eo *)o, evas_obj_grid_children_get(&ret)); + return ret; +} + +static void +_children_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_List **ret = va_arg(*list, Eina_List **); + Eina_List *new_list = NULL, *l; Evas_Object_Grid_Option *opt; - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(o, priv, NULL); + const Evas_Object_Grid_Data *priv = _pd; EINA_LIST_FOREACH(priv->children, l, opt) new_list = eina_list_append(new_list, opt->obj); - return new_list; + *ret = new_list; } EAPI Eina_Bool -evas_object_grid_mirrored_get(const Evas_Object *obj) +evas_object_grid_mirrored_get(const Evas_Object *o) { - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN_VAL(obj, priv, EINA_FALSE); - return priv->is_mirrored; + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)o, evas_obj_grid_mirrored_get(&ret)); + return ret; +} + +static void +_mirrored_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + const Evas_Object_Grid_Data *priv = _pd; + *ret = priv->is_mirrored; } EAPI void evas_object_grid_mirrored_set(Evas_Object *obj, Eina_Bool mirrored) { - EVAS_OBJECT_GRID_DATA_GET_OR_RETURN(obj, priv); + eo_do(obj, evas_obj_grid_mirrored_set(mirrored)); +} + +static void +_mirrored_set(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool mirrored = va_arg(*list, int); + + Evas_Object_Grid_Data *priv = _pd; mirrored = !!mirrored; if (priv->is_mirrored != mirrored) { priv->is_mirrored = mirrored; - _evas_object_grid_smart_calculate(obj); + _evas_object_grid_smart_calculate(o); } } + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ADD_TO), _add_to), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_SIZE_SET), _size_set), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_SIZE_GET), _size_get), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_PACK), _pack), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_UNPACK), _unpack), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_CLEAR), _clear), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_PACK_GET), _pack_get), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ITERATOR_NEW), _iterator_new), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_ACCESSOR_NEW), _accessor_new), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_CHILDREN_GET), _children_get), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_MIRRORED_GET), _mirrored_get), + EO_OP_FUNC(EVAS_OBJ_GRID_ID(EVAS_OBJ_GRID_SUB_ID_MIRRORED_SET), _mirrored_set), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_ADD_TO, "Create a grid that is child of a given element parent."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_SIZE_SET, "Set the virtual resolution for the grid."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_SIZE_GET, "Get the current virtual resolution."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_PACK, "Add a new child to a grid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_UNPACK, "Remove child from grid."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_CLEAR, "Faster way to remove all child objects from a grid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_PACK_GET, "Get the pack options for a grid child."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_ITERATOR_NEW, "Get an iterator to walk the list of children for the grid."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_ACCESSOR_NEW, "Get an accessor to get random access to the list of children for the grid."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_CHILDREN_GET, "Get the list of children for the grid."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_MIRRORED_GET, "Gets the mirrored mode of the grid."), + EO_OP_DESCRIPTION(EVAS_OBJ_GRID_SUB_ID_MIRRORED_SET, "Sets the mirrored mode of the grid."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Grid", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_GRID_BASE_ID, op_desc, EVAS_OBJ_GRID_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Grid_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_grid_class_get, &class_desc, EVAS_OBJ_SMART_CLIPPED_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_image.c b/legacy/evas/src/lib/canvas/evas_object_image.c index 66d52f61e4..4a1b3fafca 100644 --- a/legacy/evas/src/lib/canvas/evas_object_image.c +++ b/legacy/evas/src/lib/canvas/evas_object_image.c @@ -16,18 +16,22 @@ #include "../engines/common/evas_convert_colorspace.h" #include "../engines/common/evas_convert_yuv.h" +#include + +EAPI Eo_Op EVAS_OBJ_IMAGE_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_IMAGE_CLASS + #define VERBOSE_PROXY_ERROR 1 /* private magic number for image objects */ static const char o_type[] = "image"; /* private struct for rectangle object internal data */ -typedef struct _Evas_Object_Image Evas_Object_Image; +typedef struct _Evas_Object_Image Evas_Object_Image; struct _Evas_Object_Image { - DATA32 magic; - struct { int spread; Evas_Coord_Rectangle fill; @@ -93,42 +97,42 @@ struct _Evas_Object_Image }; /* private methods for image objects */ -static void evas_object_image_unload(Evas_Object *obj, Eina_Bool dirty); -static void evas_object_image_load(Evas_Object *obj); -static Evas_Coord evas_object_image_figure_x_fill(Evas_Object *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret); -static Evas_Coord evas_object_image_figure_y_fill(Evas_Object *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret); +static void evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty); +static void evas_object_image_load(Evas_Object *eo_obj); +static Evas_Coord evas_object_image_figure_x_fill(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret); +static Evas_Coord evas_object_image_figure_y_fill(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret); -static void evas_object_image_init(Evas_Object *obj); -static void *evas_object_image_new(void); -static void evas_object_image_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_image_free(Evas_Object *obj); -static void evas_object_image_render_pre(Evas_Object *obj); -static void evas_object_image_render_post(Evas_Object *obj); +static void evas_object_image_init(Evas_Object *eo_obj); +static void evas_object_image_new(Evas_Object *eo_obj); +static void evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_image_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_image_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_image_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_image_id_get(Evas_Object *obj); -static unsigned int evas_object_image_visual_id_get(Evas_Object *obj); -static void *evas_object_image_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_image_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_image_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_image_engine_data_get(Evas_Object *eo_obj); -static int evas_object_image_is_opaque(Evas_Object *obj); -static int evas_object_image_was_opaque(Evas_Object *obj); -static int evas_object_image_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); -static int evas_object_image_has_opaque_rect(Evas_Object *obj); -static int evas_object_image_get_opaque_rect(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h); -static int evas_object_image_can_map(Evas_Object *obj); +static int evas_object_image_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_image_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_image_is_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y); +static int evas_object_image_has_opaque_rect(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_image_get_opaque_rect(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h); +static int evas_object_image_can_map(Evas_Object *eo_obj); static void *evas_object_image_data_convert_internal(Evas_Object_Image *o, void *data, Evas_Colorspace to_cspace); -static void evas_object_image_filled_resize_listener(void *data, Evas *e, Evas_Object *obj, void *einfo); +static void evas_object_image_filled_resize_listener(void *data, Evas *eo_e, Evas_Object *eo_obj, void *einfo); static void _proxy_unset(Evas_Object *proxy); static void _proxy_set(Evas_Object *proxy, Evas_Object *src); static void _proxy_error(Evas_Object *proxy, void *context, void *output, void *surface, int x, int y); -static void _cleanup_tmpf(Evas_Object *obj); +static void _cleanup_tmpf(Evas_Object *eo_obj); static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_image_free, + NULL, evas_object_image_render, evas_object_image_render_pre, evas_object_image_render_post, @@ -151,56 +155,63 @@ static const Evas_Object_Func object_func = evas_object_image_can_map }; -EVAS_MEMPOOL(_mp_obj); - static void -_evas_object_image_cleanup(Evas_Object *obj, Evas_Object_Image *o) +_evas_object_image_cleanup(Evas_Object *eo_obj, Evas_Object_Image *o) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if ((o->preloading) && (o->engine_data)) { o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } - if (o->tmpf) _cleanup_tmpf(obj); - if (o->cur.source) _proxy_unset(obj); -} - -EAPI Evas_Object * -evas_object_image_add(Evas *e) -{ - Evas_Object *obj; - Evas_Object_Image *o; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return NULL; - MAGIC_CHECK_END(); - EINA_SAFETY_ON_NULL_RETURN_VAL(e->engine.func, NULL); - obj = evas_object_new(e); - evas_object_image_init(obj); - evas_object_inject(obj, e); - o = (Evas_Object_Image *)(obj->object_data); - o->cur.cspace = obj->layer->evas->engine.func->image_colorspace_get(obj->layer->evas->engine.data.output, o->engine_data); - return obj; -} - -EAPI Evas_Object * -evas_object_image_filled_add(Evas *e) -{ - Evas_Object *obj; - obj = evas_object_image_add(e); - evas_object_image_filled_set(obj, 1); - return obj; + if (o->tmpf) _cleanup_tmpf(eo_obj); + if (o->cur.source) _proxy_unset(eo_obj); } static void -_cleanup_tmpf(Evas_Object *obj) +_constructor(Eo *eo_obj, void *class_data, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = class_data; + Evas *eo_e = evas_object_evas_get(eo_parent_get(eo_obj)); + + eo_do_super(eo_obj, eo_constructor()); + evas_object_image_init(eo_obj); + evas_object_inject(eo_obj, obj, eo_e); + o->cur.cspace = obj->layer->evas->engine.func->image_colorspace_get(obj->layer->evas->engine.data.output, o->engine_data); +} + +EAPI Evas_Object * +evas_object_image_add(Evas *eo_e) +{ + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return NULL; + MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); + EINA_SAFETY_ON_NULL_RETURN_VAL(e->engine.func, NULL); + Evas_Object *eo_obj = eo_add(EVAS_OBJ_IMAGE_CLASS, eo_e); + eo_unref(eo_obj); + return eo_obj; +} + +EAPI Evas_Object * +evas_object_image_filled_add(Evas *eo_e) +{ + Evas_Object *eo_obj; + eo_obj = evas_object_image_add(eo_e); + evas_object_image_filled_set(eo_obj, 1); + return eo_obj; +} + +static void +_cleanup_tmpf(Evas_Object *eo_obj) { #ifdef HAVE_SYS_MMAN_H Evas_Object_Image *o; - o = (Evas_Object_Image *)(obj->object_data); + o = eo_data_get(eo_obj, MY_CLASS); if (!o->tmpf) return; #ifdef __linux__ #else @@ -211,20 +222,20 @@ _cleanup_tmpf(Evas_Object *obj) o->tmpf_fd = -1; o->tmpf = NULL; #else - (void) obj; + (void) eo_obj; #endif } static void -_create_tmpf(Evas_Object *obj, void *data, int size, char *format __UNUSED__) +_create_tmpf(Evas_Object *eo_obj, void *data, int size, char *format EINA_UNUSED) { #ifdef HAVE_SYS_MMAN_H Evas_Object_Image *o; char buf[PATH_MAX]; void *dst; int fd = -1; - - o = (Evas_Object_Image *)(obj->object_data); + + o = eo_data_get(eo_obj, MY_CLASS); #ifdef __linux__ snprintf(buf, sizeof(buf), "/dev/shm/.evas-tmpf-%i-%p-%i-XXXXXX", (int)getpid(), data, (int)size); @@ -277,7 +288,7 @@ _create_tmpf(Evas_Object *obj, void *data, int size, char *format __UNUSED__) memcpy(dst, data, size); munmap(dst, size); #else - (void) obj; + (void) eo_obj; (void) data; (void) size; (void) format; @@ -285,50 +296,63 @@ _create_tmpf(Evas_Object *obj, void *data, int size, char *format __UNUSED__) } EAPI void -evas_object_image_memfile_set(Evas_Object *obj, void *data, int size, char *format, char *key) +evas_object_image_memfile_set(Evas_Object *eo_obj, void *data, int size, char *format, char *key) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_memfile_set(data, size, format, key)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - _cleanup_tmpf(obj); - evas_object_image_file_set(obj, NULL, NULL); +static void +_image_memfile_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + + void *data = va_arg(*list, void *); + int size = va_arg(*list, int); + char *format = va_arg(*list, char*); + char *key = va_arg(*list, char*); + + _cleanup_tmpf(eo_obj); + evas_object_image_file_set(eo_obj, NULL, NULL); // invalidate the cache effectively - evas_object_image_alpha_set(obj, !o->cur.has_alpha); - evas_object_image_alpha_set(obj, o->cur.has_alpha); + evas_object_image_alpha_set(eo_obj, !o->cur.has_alpha); + evas_object_image_alpha_set(eo_obj, o->cur.has_alpha); if ((size < 1) || (!data)) return; - _create_tmpf(obj, data, size, format); - evas_object_image_file_set(obj, o->tmpf, key); + _create_tmpf(eo_obj, data, size, format); + evas_object_image_file_set(eo_obj, o->tmpf, key); if (!o->engine_data) { ERR("unable to load '%s' from memory", o->tmpf); - _cleanup_tmpf(obj); + _cleanup_tmpf(eo_obj); return; } } EAPI void -evas_object_image_file_set(Evas_Object *obj, const char *file, const char *key) +evas_object_image_file_set(Evas_Object *eo_obj, const char *file, const char *key) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_file_set(file, key)); +} + +static void +_image_file_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; Evas_Image_Load_Opts lo; Eina_Bool resize_call = EINA_FALSE; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - if ((o->tmpf) && (file != o->tmpf)) _cleanup_tmpf(obj); + const char *file = va_arg(*list, const char*); + const char *key = va_arg(*list, const char*); + + if ((o->tmpf) && (file != o->tmpf)) _cleanup_tmpf(eo_obj); if ((o->cur.file) && (file) && (!strcmp(o->cur.file, file))) { if ((!o->cur.key) && (!key)) @@ -341,9 +365,9 @@ evas_object_image_file_set(Evas_Object *obj, const char *file, const char *key) if (!o->engine_data) obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); */ - if (o->cur.source) _proxy_unset(obj); + if (o->cur.source) _proxy_unset(eo_obj); if (o->cur.file) eina_stringshare_del(o->cur.file); if (o->cur.key) eina_stringshare_del(o->cur.key); if (file) o->cur.file = eina_stringshare_add(file); @@ -357,7 +381,7 @@ evas_object_image_file_set(Evas_Object *obj, const char *file, const char *key) if (o->preloading) { o->preloading = EINA_FALSE; - obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, obj); + obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, eo_obj); } obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output, o->engine_data); } @@ -412,120 +436,147 @@ evas_object_image_file_set(Evas_Object *obj, const char *file, const char *key) } o->changed = EINA_TRUE; - if (resize_call) evas_object_inform_call_image_resize(obj); - evas_object_change(obj); + if (resize_call) evas_object_inform_call_image_resize(eo_obj); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_image_file_get(const Evas_Object *obj, const char **file, const char **key) +evas_object_image_file_get(const Evas_Object *eo_obj, const char **file, const char **key) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (file) *file = NULL; + if (key) *key = NULL; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_image_file_get(file, key)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (file) *file = NULL; - if (key) *key = NULL; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - if (file) *file = NULL; - if (key) *key = NULL; - return; - MAGIC_CHECK_END(); +static void +_image_file_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + const char **file = va_arg(*list, const char**); + const char **key = va_arg(*list, const char**); if (file) *file = o->cur.file; if (key) *key = o->cur.key; } EAPI Eina_Bool -evas_object_image_source_set(Evas_Object *obj, Evas_Object *src) +evas_object_image_source_set(Evas_Object *eo_obj, Evas_Object *src) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = obj->object_data; - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); + Eina_Bool result = EINA_FALSE; + eo_do(eo_obj, evas_obj_image_source_set(src, &result)); + return result; +} - if (obj->delete_me && src) +static void +_image_source_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + + Evas_Object *eo_src = va_arg(*list, Evas_Object *); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = EINA_FALSE; + + if (obj->delete_me && eo_src) { - WRN("Setting deleted object %p as image source %p", src, obj); - return EINA_FALSE; + WRN("Setting deleted object %p as image source %p", eo_src, eo_obj); + return; } - if (src) + if (eo_src) { + Evas_Object_Protected_Data *src = eo_data_get(eo_src, EVAS_OBJ_CLASS); if (src->delete_me) { - WRN("Setting object %p to deleted image source %p", src, obj); - return EINA_FALSE; + WRN("Setting object %p to deleted image source %p", eo_src, eo_obj); + return; } if (!src->layer) { - CRIT("No evas surface associated with source object (%p)", obj); - return EINA_FALSE; + CRIT("No evas surface associated with source object (%p)", eo_obj); + return; } if ((obj->layer && src->layer) && (obj->layer->evas != src->layer->evas)) { - CRIT("Setting object %p from Evas (%p) from another Evas (%p)", src, src->layer->evas, obj->layer->evas); - return EINA_FALSE; + CRIT("Setting object %p from Evas (%p) from another Evas (%p)", eo_src, src->layer->evas, obj->layer->evas); + return; } - if (src == obj) + if (eo_src == eo_obj) { CRIT("Setting object %p as a source for itself", obj); - return EINA_FALSE; + return; } } - if (o->cur.source == src) return EINA_TRUE; + if (o->cur.source == eo_src) + { + if (result) *result = EINA_TRUE; + return; + } - _evas_object_image_cleanup(obj, o); + _evas_object_image_cleanup(eo_obj, o); /* Kill the image if any */ if (o->cur.file || o->cur.key) - evas_object_image_file_set(obj, NULL, NULL); + evas_object_image_file_set(eo_obj, NULL, NULL); - if (src) _proxy_set(obj, src); - else _proxy_unset(obj); + if (eo_src) _proxy_set(eo_obj, eo_src); + else _proxy_unset(eo_obj); - return EINA_TRUE; + if (result) *result = EINA_TRUE; } EAPI Evas_Object * -evas_object_image_source_get(const Evas_Object *obj) +evas_object_image_source_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = obj->object_data; - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object *source = NULL; + eo_do((Eo *)eo_obj, evas_obj_image_source_get(&source)); + return source; +} - return o->cur.source; +static void +_image_source_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Evas_Object **source = va_arg(*list, Evas_Object **); + if (source) *source = o->cur.source; } EAPI Eina_Bool -evas_object_image_source_unset(Evas_Object *obj) +evas_object_image_source_unset(Evas_Object *eo_obj) { - return evas_object_image_source_set(obj, NULL); + Eina_Bool result = EINA_FALSE; + eo_do(eo_obj, evas_obj_image_source_set(NULL, &result)); + return result; } EAPI void -evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b) +evas_object_image_border_set(Evas_Object *eo_obj, int l, int r, int t, int b) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_border_set(l, r, t, b)); +} + +static void +_image_border_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; + + int l = va_arg(*list, int); + int r = va_arg(*list, int); + int t = va_arg(*list, int); + int b = va_arg(*list, int); - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (l < 0) l = 0; if (r < 0) r = 0; if (t < 0) t = 0; @@ -540,29 +591,30 @@ evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b) o->cur.border.b = b; o->cur.opaque_valid = 0; o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_image_border_get(const Evas_Object *obj, int *l, int *r, int *t, int *b) +evas_object_image_border_get(const Evas_Object *eo_obj, int *l, int *r, int *t, int *b) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (l) *l = 0; + if (r) *r = 0; + if (t) *t = 0; + if (b) *b = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_image_border_get(l, r, t, b)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (l) *l = 0; - if (r) *r = 0; - if (t) *t = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - if (l) *l = 0; - if (r) *r = 0; - if (t) *t = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); +static void +_image_border_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + int *l = va_arg(*list, int *); + int *r = va_arg(*list, int *); + int *t = va_arg(*list, int *); + int *b = va_arg(*list, int *); if (l) *l = o->cur.border.l; if (r) *r = o->cur.border.r; if (t) *t = o->cur.border.t; @@ -570,138 +622,165 @@ evas_object_image_border_get(const Evas_Object *obj, int *l, int *r, int *t, int } EAPI void -evas_object_image_border_center_fill_set(Evas_Object *obj, Evas_Border_Fill_Mode fill) +evas_object_image_border_center_fill_set(Evas_Object *eo_obj, Evas_Border_Fill_Mode fill) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_border_center_fill_set(fill)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); +static void +_image_border_center_fill_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Border_Fill_Mode fill = va_arg(*list, Evas_Border_Fill_Mode); + Evas_Object_Image *o = _pd; if (fill == o->cur.border.fill) return; o->cur.border.fill = fill; o->changed = EINA_TRUE; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI Evas_Border_Fill_Mode -evas_object_image_border_center_fill_get(const Evas_Object *obj) +evas_object_image_border_center_fill_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Border_Fill_Mode fill = 0; + eo_do((Eo *)eo_obj, evas_obj_image_border_center_fill_get(&fill)); + return fill; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - return o->cur.border.fill; +static void +_image_border_center_fill_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Border_Fill_Mode *fill = va_arg(*list, Evas_Border_Fill_Mode *); + const Evas_Object_Image *o = _pd; + if (fill) *fill = o->cur.border.fill; + return; } EAPI void -evas_object_image_filled_set(Evas_Object *obj, Eina_Bool setting) +evas_object_image_filled_set(Evas_Object *eo_obj, Eina_Bool setting) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_filled_set(setting)); +} +static void +_image_filled_set(Eo *eo_obj, void* _pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + + Eina_Bool setting = va_arg(*list, int); setting = !!setting; if (o->filled == setting) return; o->filled = setting; if (!o->filled) - evas_object_event_callback_del(obj, EVAS_CALLBACK_RESIZE, + evas_object_event_callback_del(eo_obj, EVAS_CALLBACK_RESIZE, evas_object_image_filled_resize_listener); else { Evas_Coord w, h; - evas_object_geometry_get(obj, NULL, NULL, &w, &h); - evas_object_image_fill_set(obj, 0, 0, w, h); + evas_object_geometry_get(eo_obj, NULL, NULL, &w, &h); + evas_object_image_fill_set(eo_obj, 0, 0, w, h); - evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, + evas_object_event_callback_add(eo_obj, EVAS_CALLBACK_RESIZE, evas_object_image_filled_resize_listener, NULL); } } EAPI Eina_Bool -evas_object_image_filled_get(const Evas_Object *obj) +evas_object_image_filled_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); + Eina_Bool fill = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_filled_get(&fill)); + return fill; +} - return o->filled; +static void +_image_filled_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Eina_Bool *fill = va_arg(*list, Eina_Bool *); + if (fill) *fill = o->filled; } EAPI void -evas_object_image_border_scale_set(Evas_Object *obj, double scale) +evas_object_image_border_scale_set(Evas_Object *eo_obj, double scale) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_border_scale_set(scale)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); +static void +_image_border_scale_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + + double scale = va_arg(*list, double); if (scale == o->cur.border.scale) return; o->cur.border.scale = scale; o->changed = EINA_TRUE; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI double -evas_object_image_border_scale_get(const Evas_Object *obj) +evas_object_image_border_scale_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 1.0; + MAGIC_CHECK_END(); + double scale = 1.0; + eo_do((Eo *)eo_obj, evas_obj_image_border_scale_get(&scale)); + return scale; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 1.0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 1.0; - MAGIC_CHECK_END(); - return o->cur.border.scale; +static void +_image_border_scale_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + double *scale = va_arg(list, double *); + if (scale) *scale = o->cur.border.scale; } EAPI void -evas_object_image_fill_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) +evas_object_image_fill_set(Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_fill_set(x, y, w, h)); +} + +static void +_image_fill_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); if (w == 0) return; if (h == 0) return; if (w < 0) w = -w; if (h < 0) h = -h; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - if ((o->cur.fill.x == x) && (o->cur.fill.y == y) && (o->cur.fill.w == w) && @@ -712,29 +791,33 @@ evas_object_image_fill_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Co o->cur.fill.h = h; o->cur.opaque_valid = 0; o->changed = EINA_TRUE; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_image_fill_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) +evas_object_image_fill_get(const Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (x) *x = 0; + if (y) *y = 0; + if (w) *w = 0; + if (h) *h = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_image_fill_get(x, y, w, h)); +} + +static void +_image_fill_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + + Evas_Coord *x = va_arg(*list, Evas_Coord *); + Evas_Coord *y = va_arg(*list, Evas_Coord *); + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (x) *x = 0; - if (y) *y = 0; - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - if (x) *x = 0; - if (y) *y = 0; - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); if (x) *x = o->cur.fill.x; if (y) *y = o->cur.fill.y; if (w) *w = o->cur.fill.w; @@ -743,52 +826,64 @@ evas_object_image_fill_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, EAPI void -evas_object_image_fill_spread_set(Evas_Object *obj, Evas_Fill_Spread spread) +evas_object_image_fill_spread_set(Evas_Object *eo_obj, Evas_Fill_Spread spread) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_fill_spread_set(spread)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); +static void +_image_fill_spread_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + Evas_Fill_Spread spread = va_arg(*list, Evas_Fill_Spread); if (spread == (Evas_Fill_Spread)o->cur.spread) return; o->cur.spread = spread; o->changed = EINA_TRUE; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI Evas_Fill_Spread -evas_object_image_fill_spread_get(const Evas_Object *obj) +evas_object_image_fill_spread_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_TEXTURE_REPEAT; + MAGIC_CHECK_END(); + Evas_Fill_Spread spread = EVAS_TEXTURE_REPEAT; + eo_do((Eo *)eo_obj, evas_obj_image_fill_spread_get(&spread)); + return spread; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_TEXTURE_REPEAT; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return EVAS_TEXTURE_REPEAT; - MAGIC_CHECK_END(); - return (Evas_Fill_Spread)o->cur.spread; +static void +_image_fill_spread_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Evas_Fill_Spread *spread = va_arg(*list, Evas_Fill_Spread *); + if (spread) *spread = (Evas_Fill_Spread)o->cur.spread; } EAPI void -evas_object_image_size_set(Evas_Object *obj, int w, int h) +evas_object_image_size_set(Evas_Object *eo_obj, int w, int h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_size_set(w, h)); +} + +static void +_image_size_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int w = va_arg(*list, int); + int h = va_arg(*list, int); + + Evas_Object_Image *o = _pd; int stride = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - _evas_object_image_cleanup(obj, o); + _evas_object_image_cleanup(eo_obj, o); if (w < 1) w = 1; if (h < 1) h = 1; if (w > 32768) return; @@ -797,6 +892,7 @@ evas_object_image_size_set(Evas_Object *obj, int w, int h) (h == o->cur.image.h)) return; o->cur.image.w = w; o->cur.image.h = h; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (o->engine_data) o->engine_data = obj->layer->evas->engine.func->image_size_set(obj->layer->evas->engine.data.output, o->engine_data, w, h); else @@ -833,83 +929,100 @@ evas_object_image_size_set(Evas_Object *obj, int w, int h) */ EVAS_OBJECT_IMAGE_FREE_FILE_AND_KEY(o); o->changed = EINA_TRUE; - evas_object_inform_call_image_resize(obj); - evas_object_change(obj); + evas_object_inform_call_image_resize(eo_obj); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_image_size_get(const Evas_Object *obj, int *w, int *h) +evas_object_image_size_get(const Evas_Object *eo_obj, int *w, int *h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (w) *w = 0; + if (h) *h = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_image_size_get(w, h)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); +static void +_image_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); if (w) *w = o->cur.image.w; if (h) *h = o->cur.image.h; } EAPI int -evas_object_image_stride_get(const Evas_Object *obj) +evas_object_image_stride_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + int stride = 0; + eo_do((Eo *)eo_obj, evas_obj_image_stride_get(&stride)); + return stride; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - return o->cur.image.stride; +static void +_image_stride_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *stride = va_arg(*list, int *); + const Evas_Object_Image *o = _pd; + if (stride) *stride = o->cur.image.stride; } EAPI Evas_Load_Error -evas_object_image_load_error_get(const Evas_Object *obj) +evas_object_image_load_error_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Load_Error load_error = 0; + eo_do((Eo *)eo_obj, evas_obj_image_load_error_get(&load_error)); + return load_error; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - return o->load_error; +static void +_image_load_error_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Load_Error *load_error = va_arg(*list, Evas_Load_Error *); + const Evas_Object_Image *o = _pd; + if (load_error) *load_error = o->load_error; } EAPI void * -evas_object_image_data_convert(Evas_Object *obj, Evas_Colorspace to_cspace) +evas_object_image_data_convert(Evas_Object *eo_obj, Evas_Colorspace to_cspace) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + void *data = NULL; + eo_do(eo_obj, evas_obj_image_data_convert(to_cspace, &data)); + return data; +} + +static void +_image_data_convert(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; + Evas_Colorspace to_cspace = va_arg(*list, Evas_Colorspace); + void **ret_data = va_arg(*list, void **); + if (ret_data) *ret_data = NULL; DATA32 *data; void* result = NULL; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return NULL; - MAGIC_CHECK_END(); if ((o->preloading) && (o->engine_data)) { o->preloading = EINA_FALSE; - obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, obj); + obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, eo_obj); } - if (!o->engine_data) return NULL; + if (!o->engine_data) return; if (o->video_surface) - o->video.update_pixels(o->video.data, obj, &o->video); - if (o->cur.cspace == to_cspace) return NULL; + o->video.update_pixels(o->video.data, eo_obj, &o->video); + if (o->cur.cspace == to_cspace) return; data = NULL; o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 0, &data, &o->load_error); result = evas_object_image_data_convert_internal(o, data, to_cspace); @@ -918,23 +1031,29 @@ evas_object_image_data_convert(Evas_Object *obj, Evas_Colorspace to_cspace) o->engine_data = obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output, o->engine_data, data); } - return result; + if (ret_data) *ret_data = result; } + EAPI void -evas_object_image_data_set(Evas_Object *obj, void *data) +evas_object_image_data_set(Evas_Object *eo_obj, void *data) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_data_set(data)); +} + +static void +_image_data_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; void *p_data; Eina_Bool resize_call = EINA_FALSE; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - _evas_object_image_cleanup(obj, o); + void *data = va_arg(*list, void *); + + _evas_object_image_cleanup(eo_obj, o); p_data = o->engine_data; if (data) { @@ -1001,25 +1120,39 @@ evas_object_image_data_set(Evas_Object *obj, void *data) o->pixels_checked_out = 0; } o->changed = EINA_TRUE; - if (resize_call) evas_object_inform_call_image_resize(obj); - evas_object_change(obj); + if (resize_call) evas_object_inform_call_image_resize(eo_obj); + evas_object_change(eo_obj, obj); } EAPI void * -evas_object_image_data_get(const Evas_Object *obj, Eina_Bool for_writing) +evas_object_image_data_get(const Evas_Object *eo_obj, Eina_Bool for_writing) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + void *data = NULL; + eo_do((Eo *)eo_obj, evas_obj_image_data_get(for_writing, &data)); + return data; +} + +static void +_image_data_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = (Evas_Object_Image *) _pd; + Eina_Bool for_writing = va_arg(*list, int); + void **ret_data = va_arg(*list, void **); DATA32 *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return NULL; - MAGIC_CHECK_END(); - if (!o->engine_data) return NULL; + if (!o->engine_data) + { + if (ret_data) *ret_data = NULL; + return; + } +#ifdef EVAS_FRAME_QUEUING + evas_common_pipe_op_image_flush(o->engine_data); +#endif + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); data = NULL; if (obj->layer->evas->engine.func->image_scale_hint_set) obj->layer->evas->engine.func->image_scale_hint_set @@ -1032,7 +1165,11 @@ evas_object_image_data_get(const Evas_Object *obj, Eina_Bool for_writing) o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, for_writing, &data, &o->load_error); /* if we fail to get engine_data, we have to return NULL */ - if (!o->engine_data) return NULL; + if (!o->engine_data) + { + if (ret_data) *ret_data = NULL; + return; + } if (o->engine_data) { @@ -1052,29 +1189,33 @@ evas_object_image_data_get(const Evas_Object *obj, Eina_Bool for_writing) EVAS_OBJECT_IMAGE_FREE_FILE_AND_KEY(o); } - return data; + if (ret_data) *ret_data = data; } EAPI void -evas_object_image_preload(Evas_Object *obj, Eina_Bool cancel) +evas_object_image_preload(Evas_Object *eo_obj, Eina_Bool cancel) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return ; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_preload(cancel)); +} + +static void +_image_preload(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return ; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return ; - MAGIC_CHECK_END(); if (!o->engine_data) { o->preloading = EINA_TRUE; - evas_object_inform_call_image_preloaded(obj); + evas_object_inform_call_image_preloaded(eo_obj); return; } // FIXME: if already busy preloading, then dont request again until // preload done + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Eina_Bool cancel = va_arg(*list, int); if (cancel) { if (o->preloading) @@ -1082,7 +1223,7 @@ evas_object_image_preload(Evas_Object *obj, Eina_Bool cancel) o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } } else @@ -1092,27 +1233,31 @@ evas_object_image_preload(Evas_Object *obj, Eina_Bool cancel) o->preloading = EINA_TRUE; obj->layer->evas->engine.func->image_data_preload_request(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } } } EAPI void -evas_object_image_data_copy_set(Evas_Object *obj, void *data) +evas_object_image_data_copy_set(Evas_Object *eo_obj, void *data) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_data_copy_set(data)); +} + +static void +_image_data_copy_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + void *data = va_arg(*list, void *); if (!data) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - _evas_object_image_cleanup(obj, o); + _evas_object_image_cleanup(eo_obj, o); if ((o->cur.image.w <= 0) || (o->cur.image.h <= 0)) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (o->engine_data) obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output, o->engine_data); @@ -1152,44 +1297,55 @@ evas_object_image_data_copy_set(Evas_Object *obj, void *data) } EAPI void -evas_object_image_data_update_add(Evas_Object *obj, int x, int y, int w, int h) +evas_object_image_data_update_add(Evas_Object *eo_obj, int x, int y, int w, int h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_data_update_add(x, y, w, h)); +} + +static void +_image_data_update_add(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; Eina_Rectangle *r; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); + int x = va_arg(*list, int); + int y = va_arg(*list, int); + int w = va_arg(*list, int); + int h = va_arg(*list, int); RECTS_CLIP_TO_RECT(x, y, w, h, 0, 0, o->cur.image.w, o->cur.image.h); if ((w <= 0) || (h <= 0)) return; NEW_RECT(r, x, y, w, h); if (r) o->pixel_updates = eina_list_append(o->pixel_updates, r); o->changed = EINA_TRUE; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_image_alpha_set(Evas_Object *obj, Eina_Bool has_alpha) +evas_object_image_alpha_set(Evas_Object *eo_obj, Eina_Bool has_alpha) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_alpha_set(has_alpha)); +} + +static void +_image_alpha_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; + Eina_Bool has_alpha = va_arg(*list, int); - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if ((o->preloading) && (o->engine_data)) { o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } if (((has_alpha) && (o->cur.has_alpha)) || ((!has_alpha) && (!o->cur.has_alpha))) @@ -1219,110 +1375,133 @@ evas_object_image_alpha_set(Evas_Object *obj, Eina_Bool has_alpha) stride = o->cur.image.w * 4; o->cur.image.stride = stride; } - evas_object_image_data_update_add(obj, 0, 0, o->cur.image.w, o->cur.image.h); + evas_object_image_data_update_add(eo_obj, 0, 0, o->cur.image.w, o->cur.image.h); EVAS_OBJECT_IMAGE_FREE_FILE_AND_KEY(o); } EAPI Eina_Bool -evas_object_image_alpha_get(const Evas_Object *obj) +evas_object_image_alpha_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Eina_Bool has_alpha = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_alpha_get(&has_alpha)); + return has_alpha; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - return o->cur.has_alpha; +static void +_image_alpha_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *has_alpha = va_arg(*list, Eina_Bool *); + const Evas_Object_Image *o = _pd; + *has_alpha = o->cur.has_alpha; } EAPI void -evas_object_image_smooth_scale_set(Evas_Object *obj, Eina_Bool smooth_scale) +evas_object_image_smooth_scale_set(Evas_Object *eo_obj, Eina_Bool smooth_scale) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_smooth_scale_set(smooth_scale)); +} + +static void +_image_smooth_scale_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool smooth_scale = va_arg(*list, int); + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (((smooth_scale) && (o->cur.smooth_scale)) || ((!smooth_scale) && (!o->cur.smooth_scale))) return; o->cur.smooth_scale = smooth_scale; o->changed = EINA_TRUE; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI Eina_Bool -evas_object_image_smooth_scale_get(const Evas_Object *obj) +evas_object_image_smooth_scale_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Eina_Bool smooth_scale = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_smooth_scale_get(&smooth_scale)); + return smooth_scale; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - return o->cur.smooth_scale; +static void +_image_smooth_scale_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *smooth_scale = va_arg(*list, Eina_Bool *); + const Evas_Object_Image *o = _pd; + if (smooth_scale) *smooth_scale = o->cur.smooth_scale; } EAPI void -evas_object_image_reload(Evas_Object *obj) +evas_object_image_reload(Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_reload()); +} + +static void +_image_reload(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if ((o->preloading) && (o->engine_data)) { o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } if ((!o->cur.file) || (o->pixels_checked_out > 0)) return; if (o->engine_data) o->engine_data = obj->layer->evas->engine.func->image_dirty_region(obj->layer->evas->engine.data.output, o->engine_data, 0, 0, o->cur.image.w, o->cur.image.h); - evas_object_image_unload(obj, 1); - evas_object_inform_call_image_unloaded(obj); - evas_object_image_load(obj); + evas_object_image_unload(eo_obj, 1); + evas_object_inform_call_image_unloaded(eo_obj); + evas_object_image_load(eo_obj); o->prev.file = NULL; o->prev.key = NULL; o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI Eina_Bool -evas_object_image_save(const Evas_Object *obj, const char *file, const char *key, const char *flags) +evas_object_image_save(const Evas_Object *eo_obj, const char *file, const char *key, const char *flags) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Eina_Bool result = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_save(file, key, flags, &result)); + return result; +} + +static void _image_save(Eo *eo_obj, void *_pd, va_list *list) +{ + const char *file = va_arg(*list, const char *); + const char *key = va_arg(*list, const char *); + const char *flags = va_arg(*list, const char *); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = 0; + DATA32 *data = NULL; int quality = 80, compress = 9, ok = 0; RGBA_Image *im; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - - if (!o->engine_data) return 0; + Evas_Object_Image *o = _pd; + if (!o->engine_data) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 0, &data, &o->load_error); if (flags) { @@ -1369,23 +1548,32 @@ evas_object_image_save(const Evas_Object *obj, const char *file, const char *key o->engine_data = obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output, o->engine_data, data); - return ok; + if (result) *result = ok; } EAPI Eina_Bool -evas_object_image_pixels_import(Evas_Object *obj, Evas_Pixel_Import_Source *pixels) +evas_object_image_pixels_import(Evas_Object *eo_obj, Evas_Pixel_Import_Source *pixels) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EINA_FALSE; + MAGIC_CHECK_END(); + Eina_Bool result = EINA_FALSE; + eo_do(eo_obj, evas_obj_image_pixels_import(pixels, &result)); + return result; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - _evas_object_image_cleanup(obj, o); - if ((pixels->w != o->cur.image.w) || (pixels->h != o->cur.image.h)) return 0; +static void +_image_pixels_import(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + + Evas_Pixel_Import_Source *pixels = va_arg(*list, Evas_Pixel_Import_Source *); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = 0; + + _evas_object_image_cleanup(eo_obj, o); + if ((pixels->w != o->cur.image.w) || (pixels->h != o->cur.image.h)) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); switch (pixels->format) { #if 0 @@ -1414,7 +1602,7 @@ evas_object_image_pixels_import(Evas_Object *obj, Evas_Pixel_Import_Source *pixe o->engine_data, o->cur.has_alpha); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } break; @@ -1437,199 +1625,247 @@ evas_object_image_pixels_import(Evas_Object *obj, Evas_Pixel_Import_Source *pixe o->engine_data = obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output, o->engine_data, o->cur.has_alpha); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } break; #endif default: - return 0; + return; break; } - return 1; + if (result) *result = 1; + return; } EAPI void -evas_object_image_pixels_get_callback_set(Evas_Object *obj, Evas_Object_Image_Pixels_Get_Cb func, void *data) +evas_object_image_pixels_get_callback_set(Evas_Object *eo_obj, Evas_Object_Image_Pixels_Get_Cb func, void *data) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_pixels_get_callback_set(func, data)); +} + +static void +_image_pixels_get_callback_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Image_Pixels_Get_Cb func = va_arg(*list, Evas_Object_Image_Pixels_Get_Cb); + void *data = va_arg(*list, void *); + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); o->func.get_pixels = func; o->func.get_pixels_data = data; } EAPI void -evas_object_image_pixels_dirty_set(Evas_Object *obj, Eina_Bool dirty) +evas_object_image_pixels_dirty_set(Evas_Object *eo_obj, Eina_Bool dirty) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_pixels_dirty_set(dirty)); +} + +static void +_image_pixels_dirty_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool dirty = va_arg(*list, int); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (dirty) o->dirty_pixels = EINA_TRUE; else o->dirty_pixels = EINA_FALSE; o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI Eina_Bool -evas_object_image_pixels_dirty_get(const Evas_Object *obj) +evas_object_image_pixels_dirty_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Eina_Bool dirty = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_pixels_dirty_get(&dirty)); + return dirty; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - if (o->dirty_pixels) return 1; - return 0; +static void +_image_pixels_dirty_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *dirty = va_arg(*list, Eina_Bool *); + const Evas_Object_Image *o = _pd; + + *dirty = (o->dirty_pixels ? 1 : 0); } EAPI void -evas_object_image_load_dpi_set(Evas_Object *obj, double dpi) +evas_object_image_load_dpi_set(Evas_Object *eo_obj, double dpi) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_load_dpi_set(dpi)); +} + +static void +_image_load_dpi_set(Eo *eo_obj, void *_pd, va_list *list) +{ + double dpi = va_arg(*list, double); + + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (dpi == o->load_opts.dpi) return; o->load_opts.dpi = dpi; if (o->cur.file) { - evas_object_image_unload(obj, 0); - evas_object_inform_call_image_unloaded(obj); - evas_object_image_load(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_image_unload(eo_obj, 0); + evas_object_inform_call_image_unloaded(eo_obj); + evas_object_image_load(eo_obj); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } EAPI double -evas_object_image_load_dpi_get(const Evas_Object *obj) +evas_object_image_load_dpi_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0.0; + MAGIC_CHECK_END(); + double dpi = 0.0; + eo_do((Eo *)eo_obj, evas_obj_image_load_dpi_get(&dpi)); + return dpi; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0.0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0.0; - MAGIC_CHECK_END(); - return o->load_opts.dpi; +static void +_image_load_dpi_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + double *dpi = va_arg(*list, double *); + *dpi = o->load_opts.dpi; } EAPI void -evas_object_image_load_size_set(Evas_Object *obj, int w, int h) +evas_object_image_load_size_set(Evas_Object *eo_obj, int w, int h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_load_size_set(w, h)); +} + +static void +_image_load_size_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int w = va_arg(*list, int); + int h = va_arg(*list, int); + + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if ((o->load_opts.w == w) && (o->load_opts.h == h)) return; o->load_opts.w = w; o->load_opts.h = h; if (o->cur.file) { - evas_object_image_unload(obj, 0); - evas_object_inform_call_image_unloaded(obj); - evas_object_image_load(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_image_unload(eo_obj, 0); + evas_object_inform_call_image_unloaded(eo_obj); + evas_object_image_load(eo_obj); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } EAPI void -evas_object_image_load_size_get(const Evas_Object *obj, int *w, int *h) +evas_object_image_load_size_get(const Evas_Object *eo_obj, int *w, int *h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_image_load_size_get(w, h)); +} + +static void +_image_load_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); + const Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (w) *w = o->load_opts.w; if (h) *h = o->load_opts.h; } EAPI void -evas_object_image_load_scale_down_set(Evas_Object *obj, int scale_down) +evas_object_image_load_scale_down_set(Evas_Object *eo_obj, int scale_down) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_load_scale_down_set(scale_down)); +} + +static void +_image_load_scale_down_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int scale_down = va_arg(*list, int); + + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (o->load_opts.scale_down_by == scale_down) return; o->load_opts.scale_down_by = scale_down; if (o->cur.file) { - evas_object_image_unload(obj, 0); - evas_object_inform_call_image_unloaded(obj); - evas_object_image_load(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_image_unload(eo_obj, 0); + evas_object_inform_call_image_unloaded(eo_obj); + evas_object_image_load(eo_obj); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } EAPI int -evas_object_image_load_scale_down_get(const Evas_Object *obj) +evas_object_image_load_scale_down_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + int scale_down = 0; + eo_do((Eo *)eo_obj, evas_obj_image_load_scale_down_get(&scale_down)); + return scale_down; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return 0; - MAGIC_CHECK_END(); - return o->load_opts.scale_down_by; +static void +_image_load_scale_down_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *scale_down = va_arg(*list, int *); + const Evas_Object_Image *o = _pd; + *scale_down = o->load_opts.scale_down_by; } EAPI void -evas_object_image_load_region_set(Evas_Object *obj, int x, int y, int w, int h) +evas_object_image_load_region_set(Evas_Object *eo_obj, int x, int y, int w, int h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_load_region_set(x, y, w, h)); +} + +static void +_image_load_region_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int x = va_arg(*list, int); + int y = va_arg(*list, int); + int w = va_arg(*list, int); + int h = va_arg(*list, int); + + Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if ((o->load_opts.region.x == x) && (o->load_opts.region.y == y) && (o->load_opts.region.w == w) && (o->load_opts.region.h == h)) return; o->load_opts.region.x = x; @@ -1638,26 +1874,33 @@ evas_object_image_load_region_set(Evas_Object *obj, int x, int y, int w, int h) o->load_opts.region.h = h; if (o->cur.file) { - evas_object_image_unload(obj, 0); - evas_object_inform_call_image_unloaded(obj); - evas_object_image_load(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_image_unload(eo_obj, 0); + evas_object_inform_call_image_unloaded(eo_obj); + evas_object_image_load(eo_obj); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } EAPI void -evas_object_image_load_region_get(const Evas_Object *obj, int *x, int *y, int *w, int *h) +evas_object_image_load_region_get(const Evas_Object *eo_obj, int *x, int *y, int *w, int *h) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_image_load_region_get(x, y, w, h)); +} + +static void +_image_load_region_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *x = va_arg(*list, int *); + int *y = va_arg(*list, int *); + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); + const Evas_Object_Image *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); if (x) *x = o->load_opts.region.x; if (y) *y = o->load_opts.region.y; if (w) *w = o->load_opts.region.w; @@ -1665,49 +1908,58 @@ evas_object_image_load_region_get(const Evas_Object *obj, int *x, int *y, int *w } EAPI void -evas_object_image_load_orientation_set(Evas_Object *obj, Eina_Bool enable) +evas_object_image_load_orientation_set(Evas_Object *eo_obj, Eina_Bool enable) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_load_orientation_set(enable)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); +static void +_image_load_orientation_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool enable = va_arg(*list, int); + Evas_Object_Image *o = _pd; o->load_opts.orientation = !!enable; } EAPI Eina_Bool -evas_object_image_load_orientation_get(const Evas_Object *obj) +evas_object_image_load_orientation_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EINA_FALSE; + MAGIC_CHECK_END(); + Eina_Bool enable = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_load_orientation_get(&enable)); + return enable; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return EINA_FALSE; - MAGIC_CHECK_END(); - return o->load_opts.orientation; +static void +_image_load_orientation_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *enable = va_arg(*list, Eina_Bool *); + const Evas_Object_Image *o = _pd; + *enable = o->load_opts.orientation; } EAPI void -evas_object_image_colorspace_set(Evas_Object *obj, Evas_Colorspace cspace) +evas_object_image_colorspace_set(Evas_Object *eo_obj, Evas_Colorspace cspace) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_colorspace_set(cspace)); +} - _evas_object_image_cleanup(obj, o); +static void +_image_colorspace_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Colorspace cspace = va_arg(*list, Evas_Colorspace); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; + + _evas_object_image_cleanup(eo_obj, o); o->cur.cspace = cspace; if (o->engine_data) @@ -1715,37 +1967,45 @@ evas_object_image_colorspace_set(Evas_Object *obj, Evas_Colorspace cspace) } EAPI Evas_Colorspace -evas_object_image_colorspace_get(const Evas_Object *obj) +evas_object_image_colorspace_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_COLORSPACE_ARGB8888; + MAGIC_CHECK_END(); + Evas_Colorspace cspace = EVAS_COLORSPACE_ARGB8888; + eo_do((Eo *)eo_obj, evas_obj_image_colorspace_get(&cspace)); + return cspace; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_COLORSPACE_ARGB8888; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return EVAS_COLORSPACE_ARGB8888; - MAGIC_CHECK_END(); - return o->cur.cspace; +static void +_image_colorspace_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Colorspace *cspace = va_arg(*list, Evas_Colorspace *); + const Evas_Object_Image *o = _pd; + *cspace = o->cur.cspace; } EAPI void -evas_object_image_video_surface_set(Evas_Object *obj, Evas_Video_Surface *surf) +evas_object_image_video_surface_set(Evas_Object *eo_obj, Evas_Video_Surface *surf) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_video_surface_set(surf)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - _evas_object_image_cleanup(obj, o); +static void +_image_video_surface_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Video_Surface *surf = va_arg(*list, Evas_Video_Surface *); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; + + _evas_object_image_cleanup(eo_obj, o); if (o->video_surface) { o->video_surface = EINA_FALSE; - obj->layer->evas->video_objects = eina_list_remove(obj->layer->evas->video_objects, obj); + obj->layer->evas->video_objects = eina_list_remove(obj->layer->evas->video_objects, eo_obj); } if (surf) @@ -1763,7 +2023,7 @@ evas_object_image_video_surface_set(Evas_Object *obj, Evas_Video_Surface *surf) o->video_surface = EINA_TRUE; o->video = *surf; - obj->layer->evas->video_objects = eina_list_append(obj->layer->evas->video_objects, obj); + obj->layer->evas->video_objects = eina_list_append(obj->layer->evas->video_objects, eo_obj); } else { @@ -1778,34 +2038,43 @@ evas_object_image_video_surface_set(Evas_Object *obj, Evas_Video_Surface *surf) } EAPI const Evas_Video_Surface * -evas_object_image_video_surface_get(const Evas_Object *obj) +evas_object_image_video_surface_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + const Evas_Video_Surface *surf = NULL; + eo_do((Eo *)eo_obj, evas_obj_image_video_surface_get(&surf)); + return surf; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return NULL; - MAGIC_CHECK_END(); - if (!o->video_surface) return NULL; - return &o->video; +static void +_image_video_surface_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Video_Surface **surf = va_arg(*list, const Evas_Video_Surface **); + const Evas_Object_Image *o = _pd; + + *surf = (!o->video_surface ? NULL : &o->video); } EAPI void -evas_object_image_native_surface_set(Evas_Object *obj, Evas_Native_Surface *surf) +evas_object_image_native_surface_set(Evas_Object *eo_obj, Evas_Native_Surface *surf) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_native_surface_set(surf)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - _evas_object_image_cleanup(obj, o); +static void +_image_native_surface_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Native_Surface *surf = va_arg(*list, Evas_Native_Surface *); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; + + _evas_object_image_cleanup(eo_obj, o); if (!obj->layer->evas->engine.func->image_native_set) return; if ((surf) && ((surf->version < 2) || @@ -1814,33 +2083,44 @@ evas_object_image_native_surface_set(Evas_Object *obj, Evas_Native_Surface *surf } EAPI Evas_Native_Surface * -evas_object_image_native_surface_get(const Evas_Object *obj) +evas_object_image_native_surface_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + Evas_Native_Surface *surf = NULL; + eo_do((Eo *)eo_obj, evas_obj_image_native_surface_get(&surf)); + return surf; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return NULL; - MAGIC_CHECK_END(); - if (!obj->layer->evas->engine.func->image_native_get) return NULL; - return obj->layer->evas->engine.func->image_native_get(obj->layer->evas->engine.data.output, o->engine_data); +static void +_image_native_surface_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Native_Surface **surf = va_arg(*list, Evas_Native_Surface **); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + const Evas_Object_Image *o = _pd; + + *surf = + (!obj->layer->evas->engine.func->image_native_get ? NULL : + obj->layer->evas->engine.func->image_native_get(obj->layer->evas->engine.data.output, o->engine_data)); } EAPI void -evas_object_image_scale_hint_set(Evas_Object *obj, Evas_Image_Scale_Hint hint) +evas_object_image_scale_hint_set(Evas_Object *eo_obj, Evas_Image_Scale_Hint hint) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_scale_hint_set(hint)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); +static void +_image_scale_hint_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Image_Scale_Hint hint = va_arg(*list, Evas_Image_Scale_Hint); if (o->scale_hint == hint) return; o->scale_hint = hint; if (o->engine_data) @@ -1862,32 +2142,39 @@ evas_object_image_scale_hint_set(Evas_Object *obj, Evas_Image_Scale_Hint hint) } EAPI Evas_Image_Scale_Hint -evas_object_image_scale_hint_get(const Evas_Object *obj) +evas_object_image_scale_hint_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_IMAGE_SCALE_HINT_NONE; + MAGIC_CHECK_END(); + Evas_Image_Scale_Hint hint = EVAS_IMAGE_SCALE_HINT_NONE; + eo_do((Eo *)eo_obj, evas_obj_image_scale_hint_get(&hint)); + return hint; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_IMAGE_SCALE_HINT_NONE; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return EVAS_IMAGE_SCALE_HINT_NONE; - MAGIC_CHECK_END(); - return o->scale_hint; +static void +_image_scale_hint_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Evas_Image_Scale_Hint *hint = va_arg(*list, Evas_Image_Scale_Hint *); + *hint = o->scale_hint; } EAPI void -evas_object_image_content_hint_set(Evas_Object *obj, Evas_Image_Content_Hint hint) +evas_object_image_content_hint_set(Evas_Object *eo_obj, Evas_Image_Content_Hint hint) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_content_hint_set(hint)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); +static void +_image_content_hint_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Image *o = _pd; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Image_Content_Hint hint = va_arg(*list, Evas_Image_Content_Hint); if (o->content_hint == hint) return; o->content_hint = hint; if (o->engine_data) @@ -1909,20 +2196,12 @@ evas_object_image_content_hint_set(Evas_Object *obj, Evas_Image_Content_Hint hin } EAPI void -evas_object_image_alpha_mask_set(Evas_Object *obj, Eina_Bool ismask) +evas_object_image_alpha_mask_set(Evas_Object *eo_obj, Eina_Bool ismask) { - Evas_Object_Image *o; - + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); if (!ismask) return; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - /* Convert to A8 if not already */ /* done */ @@ -1931,165 +2210,205 @@ evas_object_image_alpha_mask_set(Evas_Object *obj, Eina_Bool ismask) #define FRAME_MAX 1024 EAPI Evas_Image_Content_Hint -evas_object_image_content_hint_get(const Evas_Object *obj) +evas_object_image_content_hint_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_IMAGE_CONTENT_HINT_NONE; + MAGIC_CHECK_END(); + Evas_Image_Content_Hint hint = EVAS_IMAGE_CONTENT_HINT_NONE; + eo_do((Eo *)eo_obj, evas_obj_image_content_hint_get(&hint)); + return hint; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_IMAGE_CONTENT_HINT_NONE; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return EVAS_IMAGE_CONTENT_HINT_NONE; - MAGIC_CHECK_END(); - return o->content_hint; +static void +_image_content_hint_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Evas_Image_Content_Hint *hint = va_arg(*list, Evas_Image_Content_Hint *); + + *hint = o->content_hint; } EAPI Eina_Bool -evas_object_image_region_support_get(const Evas_Object *obj) +evas_object_image_region_support_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *) (obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); + Eina_Bool region = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_region_support_get(®ion)); + return region; +} - return obj->layer->evas->engine.func->image_can_region_get( +static void +_image_region_support_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + const Evas_Object_Image *o = _pd; + + Eina_Bool *region = va_arg(*list, Eina_Bool *); + *region = obj->layer->evas->engine.func->image_can_region_get( obj->layer->evas->engine.data.output, o->engine_data); } /* animated feature */ EAPI Eina_Bool -evas_object_image_animated_get(const Evas_Object *obj) +evas_object_image_animated_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); + Eina_Bool animated = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_image_animated_get(&animated)); + return animated; +} - if (obj->layer->evas->engine.func->image_animated_get) - return obj->layer->evas->engine.func->image_animated_get(obj->layer->evas->engine.data.output, o->engine_data); - return EINA_FALSE; +static void +_image_animated_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool *animated = va_arg(*list, Eina_Bool *); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + const Evas_Object_Image *o = _pd; + + *animated = + obj->layer->evas->engine.func->image_animated_get ? + obj->layer->evas->engine.func->image_animated_get(obj->layer->evas->engine.data.output, o->engine_data) : + EINA_FALSE; } EAPI int -evas_object_image_animated_frame_count_get(const Evas_Object *obj) +evas_object_image_animated_frame_count_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return -1; MAGIC_CHECK_END(); + int frame_count = -1; + eo_do((Eo *)eo_obj, evas_obj_image_animated_frame_count_get(&frame_count)); + return frame_count; +} + +static void +_image_animated_frame_count_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + int *frame_count = va_arg(*list, int *); + *frame_count = -1; + + if (!evas_object_image_animated_get(eo_obj)) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); - if (!evas_object_image_animated_get(obj)) return -1; if (obj->layer->evas->engine.func->image_animated_frame_count_get) - return obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data); - return -1; + *frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data); } EAPI Evas_Image_Animated_Loop_Hint -evas_object_image_animated_loop_type_get(const Evas_Object *obj) +evas_object_image_animated_loop_type_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_IMAGE_ANIMATED_HINT_NONE; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EVAS_IMAGE_ANIMATED_HINT_NONE; MAGIC_CHECK_END(); + Evas_Image_Animated_Loop_Hint hint = EVAS_IMAGE_ANIMATED_HINT_NONE; + eo_do((Eo *)eo_obj, evas_obj_image_animated_loop_type_get(&hint)); + return hint; +} - if (!evas_object_image_animated_get(obj)) return EVAS_IMAGE_ANIMATED_HINT_NONE; +static void +_image_animated_loop_type_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + + Evas_Image_Animated_Loop_Hint *hint = va_arg(*list, Evas_Image_Animated_Loop_Hint *); + *hint = EVAS_IMAGE_ANIMATED_HINT_NONE; + if (!evas_object_image_animated_get(eo_obj)) return; if (obj->layer->evas->engine.func->image_animated_loop_type_get) - return obj->layer->evas->engine.func->image_animated_loop_type_get(obj->layer->evas->engine.data.output, o->engine_data); - return EVAS_IMAGE_ANIMATED_HINT_NONE; + *hint = obj->layer->evas->engine.func->image_animated_loop_type_get(obj->layer->evas->engine.data.output, o->engine_data); } EAPI int -evas_object_image_animated_loop_count_get(const Evas_Object *obj) +evas_object_image_animated_loop_count_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return -1; MAGIC_CHECK_END(); + int loop_count = -1; + eo_do((Eo *)eo_obj, evas_obj_image_animated_loop_count_get(&loop_count)); + return loop_count; +} - if (!evas_object_image_animated_get(obj)) return -1; +static void +_image_animated_loop_count_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Object_Image *o = _pd; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); - if (obj->layer->evas->engine.func->image_animated_loop_count_get) - return obj->layer->evas->engine.func->image_animated_loop_count_get(obj->layer->evas->engine.data.output, o->engine_data); - return -1; + int *loop_count = va_arg(*list, int *); + *loop_count = -1; + if (!evas_object_image_animated_get(eo_obj)) return; + + *loop_count = + obj->layer->evas->engine.func->image_animated_loop_count_get ? + obj->layer->evas->engine.func->image_animated_loop_count_get(obj->layer->evas->engine.data.output, o->engine_data) : + -1; } EAPI double -evas_object_image_animated_frame_duration_get(const Evas_Object *obj, int start_frame, int frame_num) +evas_object_image_animated_frame_duration_get(const Evas_Object *eo_obj, int start_frame, int frame_num) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return -1; + MAGIC_CHECK_END(); + double frame_duration = -1; + eo_do((Eo *)eo_obj, evas_obj_image_animated_frame_duration_get(start_frame, frame_num, &frame_duration)); + return frame_duration; +} + +static void +_image_animated_frame_duration_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + const Evas_Object_Image *o = _pd; int frame_count = 0; - if (start_frame < 1) return -1; - if (frame_num < 0) return -1; + int start_frame = va_arg(*list, int); + int frame_num = va_arg(*list, int); + double *frame_duration = va_arg(*list, double *); + *frame_duration = -1; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return -1; - MAGIC_CHECK_END(); - - if (!evas_object_image_animated_get(obj)) return -1; - - if (!obj->layer->evas->engine.func->image_animated_frame_count_get) return -1; + if (!obj->layer->evas->engine.func->image_animated_frame_count_get) return; frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data); - if ((start_frame + frame_num) > frame_count) return -1; + if ((start_frame + frame_num) > frame_count) return; if (obj->layer->evas->engine.func->image_animated_frame_duration_get) - return obj->layer->evas->engine.func->image_animated_frame_duration_get(obj->layer->evas->engine.data.output, o->engine_data, start_frame, frame_num); - return -1; + *frame_duration = obj->layer->evas->engine.func->image_animated_frame_duration_get(obj->layer->evas->engine.data.output, o->engine_data, start_frame, frame_num); } EAPI void -evas_object_image_animated_frame_set(Evas_Object *obj, int frame_index) +evas_object_image_animated_frame_set(Evas_Object *eo_obj, int frame_index) { - Evas_Object_Image *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_image_animated_frame_set(frame_index)); +} + +static void +_image_animated_frame_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = _pd; int frame_count = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); - if (!o->cur.file) return; + int frame_index = va_arg(*list, int); if (o->cur.frame == frame_index) return; - if (!evas_object_image_animated_get(obj)) return; + if (!evas_object_image_animated_get(eo_obj)) return; - frame_count = evas_object_image_animated_frame_count_get(obj); + frame_count = evas_object_image_animated_frame_count_get(eo_obj); /* limit the size of frame to FRAME_MAX */ if ((frame_count > FRAME_MAX) || (frame_count < 0) || (frame_index > frame_count)) @@ -2103,115 +2422,149 @@ evas_object_image_animated_frame_set(Evas_Object *obj, int frame_index) o->cur.frame = frame_index; o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI void -evas_image_cache_flush(Evas *e) +evas_image_cache_flush(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_image_cache_flush()); +} +void +_canvas_image_cache_flush(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; e->engine.func->image_cache_flush(e->engine.data.output); } EAPI void -evas_image_cache_reload(Evas *e) +evas_image_cache_reload(Evas *eo_e) { + eo_do(eo_e, evas_canvas_image_cache_reload()); +} + +void +_canvas_image_cache_reload(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; Evas_Layer *layer; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); - - evas_image_cache_flush(e); + evas_image_cache_flush(eo_e); EINA_INLIST_FOREACH(e->layers, layer) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; - EINA_INLIST_FOREACH(layer->objects, obj) - { - Evas_Object_Image *o; - - o = (Evas_Object_Image *)(obj->object_data); - if (o->magic == MAGIC_OBJ_IMAGE) + EINA_INLIST_FOREACH(layer->objects, obj) + { + if (eo_isa(obj->object, MY_CLASS)) { - evas_object_image_unload(obj, 1); - evas_object_inform_call_image_unloaded(obj); + evas_object_image_unload(obj->object, 1); + evas_object_inform_call_image_unloaded(obj->object); } - } + } } - evas_image_cache_flush(e); + evas_image_cache_flush(eo_e); EINA_INLIST_FOREACH(e->layers, layer) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; - EINA_INLIST_FOREACH(layer->objects, obj) - { - Evas_Object_Image *o; - - o = (Evas_Object_Image *)(obj->object_data); - if (o->magic == MAGIC_OBJ_IMAGE) + EINA_INLIST_FOREACH(layer->objects, obj) + { + if (eo_isa(obj->object, MY_CLASS)) { - evas_object_image_load(obj); + Evas_Object_Image *o = eo_data_get(obj->object, MY_CLASS); + evas_object_image_load(obj->object); o->changed = EINA_TRUE; - evas_object_change(obj); + evas_object_change(obj->object, obj); } - } + } } - evas_image_cache_flush(e); + evas_image_cache_flush(eo_e); } EAPI void -evas_image_cache_set(Evas *e, int size) +evas_image_cache_set(Evas *eo_e, int size) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_image_cache_set(size)); +} +void +_canvas_image_cache_set(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int size = va_arg(*list, int); + Evas_Public_Data *e = _pd; if (size < 0) size = 0; e->engine.func->image_cache_set(e->engine.data.output, size); } EAPI int -evas_image_cache_get(const Evas *e) +evas_image_cache_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); + int ret = 0; + eo_do((Eo *)eo_e, evas_canvas_image_cache_get(&ret)); + return ret; +} - return e->engine.func->image_cache_get(e->engine.data.output); +void +_canvas_image_cache_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *ret = va_arg(*list, int *); + const Evas_Public_Data *e = _pd; + *ret = e->engine.func->image_cache_get(e->engine.data.output); } EAPI Eina_Bool -evas_image_max_size_get(const Evas *e, int *maxw, int *maxh) +evas_image_max_size_get(const Evas *eo_e, int *maxw, int *maxh) { - int w = 0, h = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return EINA_FALSE; MAGIC_CHECK_END(); + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)eo_e, evas_canvas_image_max_size_get(maxw, maxh, &ret)); + return ret; +} +void +_canvas_image_max_size_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *maxw = va_arg(*list, int *); + int *maxh = va_arg(*list, int *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; + int w = 0, h = 0; + + const Evas_Public_Data *e = _pd; if (maxw) *maxw = 0xffff; if (maxh) *maxh = 0xffff; - if (!e->engine.func->image_max_size_get) return EINA_FALSE; + if (!e->engine.func->image_max_size_get) return; e->engine.func->image_max_size_get(e->engine.data.output, &w, &h); if (maxw) *maxw = w; if (maxh) *maxh = h; - return EINA_TRUE; + if (ret) *ret = EINA_TRUE; } /* all nice and private */ static void _proxy_unset(Evas_Object *proxy) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(proxy, MY_CLASS); - o = proxy->object_data; if (!o->cur.source) return; - o->cur.source->proxy.proxies = eina_list_remove(o->cur.source->proxy.proxies, proxy); + Evas_Object_Protected_Data *cur_source = eo_data_get(o->cur.source, EVAS_OBJ_CLASS); + + cur_source->proxy.proxies = eina_list_remove(cur_source->proxy.proxies, proxy); o->cur.source = NULL; if (o->cur.defmap) @@ -2223,18 +2576,17 @@ _proxy_unset(Evas_Object *proxy) static void -_proxy_set(Evas_Object *proxy, Evas_Object *src) +_proxy_set(Evas_Object *eo_proxy, Evas_Object *eo_src) { - Evas_Object_Image *o; + Evas_Object_Protected_Data *src = eo_data_get(eo_src, EVAS_OBJ_CLASS); + Evas_Object_Image *o = eo_data_get(eo_proxy, MY_CLASS); - o = proxy->object_data; + evas_object_image_file_set(eo_proxy, NULL, NULL); - evas_object_image_file_set(proxy, NULL, NULL); - - o->cur.source = src; + o->cur.source = eo_src; o->load_error = EVAS_LOAD_ERROR_NONE; - src->proxy.proxies = eina_list_append(src->proxy.proxies, proxy); + src->proxy.proxies = eina_list_append(src->proxy.proxies, eo_proxy); src->proxy.redraw = EINA_TRUE; } @@ -2242,7 +2594,7 @@ _proxy_set(Evas_Object *proxy, Evas_Object *src) * Give them some pixels. A random color */ static void -_proxy_error(Evas_Object *proxy, void *context, void *output, void *surface, +_proxy_error(Evas_Object *eo_proxy, void *context, void *output, void *surface, int x, int y) { Evas_Func *func; @@ -2254,6 +2606,7 @@ _proxy_error(Evas_Object *proxy, void *context, void *output, void *surface, * If it bugs you, just fix it. Don't tell me */ if (VERBOSE_PROXY_ERROR) printf("Err: Argh! Recursive proxies.\n"); + Evas_Object_Protected_Data *proxy = eo_data_get(eo_proxy, EVAS_OBJ_CLASS); func = proxy->layer->evas->engine.func; func->context_color_set(output, context, r, g, b, 255); func->context_multiplier_unset(output, context); @@ -2267,10 +2620,10 @@ _proxy_error(Evas_Object *proxy, void *context, void *output, void *surface, /* static void -_proxy_subrender_recurse(Evas_Object *obj, Evas_Object *clip, void *output, void *surface, void *ctx, int x, int y) +_proxy_subrender_recurse(Evas_Object *eo_obj, Evas_Object *clip, void *output, void *surface, void *ctx, int x, int y) { - Evas_Object *obj2; - Evas *e = obj->layer->evas; + Evas_Object *eo_obj2; + Evas *eo_e = obj->layer->evas; if (obj->clip.clipees) return; if (!obj->cur.visible) return; @@ -2280,21 +2633,21 @@ _proxy_subrender_recurse(Evas_Object *obj, Evas_Object *clip, void *output, void if ((obj->cur.cache.clip.a == 0) && (obj->cur.render_op == EVAS_RENDER_BLEND)) return; } - if ((obj->func->is_visible) && (!obj->func->is_visible(obj))) return; + if ((obj->func->is_visible) && (!obj->func->is_visible(eo_obj))) return; if (!obj->pre_render_done) - obj->func->render_pre(obj); + obj->func->render_pre(eo_obj); ctx = e->engine.func->context_new(output); - if (obj->smart.smart) + if (obj->is_smart) { - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), obj2) + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2) { _proxy_subrender_recurse(obj2, clip, output, surface, ctx, x, y); } } else { - obj->func->render(obj, output, ctx, surface, x, y); + obj->func->render(eo_obj, output, ctx, surface, x, y); } e->engine.func->context_free(output, ctx); } @@ -2306,13 +2659,15 @@ _proxy_subrender_recurse(Evas_Object *obj, Evas_Object *clip, void *output, void * Used to force a draw if necessary, else just makes sures it's available. */ static void -_proxy_subrender(Evas *e, Evas_Object *source) +_proxy_subrender(Evas *eo_e, Evas_Object *eo_source) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); void *ctx; -/* Evas_Object *obj2, *clip;*/ +/* Evas_Object *eo_obj2, *clip;*/ int w, h; - if (!source) return; + if (!eo_source) return; + Evas_Object_Protected_Data *source = eo_data_get(eo_source, EVAS_OBJ_CLASS); w = source->cur.geometry.w; h = source->cur.geometry.h; @@ -2348,7 +2703,7 @@ _proxy_subrender(Evas *e, Evas_Object *source) e->engine.func->context_free(e->engine.data.output, ctx); ctx = e->engine.func->context_new(e->engine.data.output); - evas_render_mapped(e, source, ctx, source->proxy.surface, + evas_render_mapped(eo_e, eo_source, source, ctx, source->proxy.surface, -source->cur.geometry.x, -source->cur.geometry.y, 1, 0, 0, e->output.w, e->output.h @@ -2361,7 +2716,7 @@ _proxy_subrender(Evas *e, Evas_Object *source) (e->engine.data.output, source->proxy.surface, 0, 0, w, h); /* ctx = e->engine.func->context_new(e->engine.data.output); - if (source->smart.smart) + if (eo_isa(source, EVAS_OBJ_SMART_CLASS)) { clip = evas_object_smart_clipped_clipper_get(source); EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(source), obj2) @@ -2396,27 +2751,27 @@ _proxy_subrender(Evas *e, Evas_Object *source) * possible to merge I guess */ static void -image_filter_draw_under_recurse(Evas *e, Evas_Object *obj, Evas_Object *stop, +image_filter_draw_under_recurse(Evas *eo_e, Evas_Object *eo_obj, Evas_Object *stop, void *output, void *ctx, void *surface, int x, int y) { - Evas_Object *obj2; + Evas_Object *eo_obj2; if (obj->clip.clipees) return; /* FIXME: Doing bounding box test */ - if (!evas_object_is_in_output_rect(obj, stop->cur.geometry.x, + if (!evas_object_is_in_output_rect(eo_obj, stop->cur.geometry.x, stop->cur.geometry.y, stop->cur.geometry.w, stop->cur.geometry.h)) return; - if (!evas_object_is_visible(obj)) return; + if (!evas_object_is_visible(eo_obj)) return; obj->pre_render_done = 1; ctx = e->engine.func->context_new(output); - if (obj->smart.smart) + if (obj->is_smart) { - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), obj2) + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2) { if (obj2 == stop) return; image_filter_draw_under_recurse(e, obj2, stop, output, surface, @@ -2424,7 +2779,7 @@ image_filter_draw_under_recurse(Evas *e, Evas_Object *obj, Evas_Object *stop, } } else - obj->func->render(obj, output, ctx, surface, x ,y); + obj->func->render(eo_obj, output, ctx, surface, x ,y); e->engine.func->context_free(output, ctx); } @@ -2432,7 +2787,7 @@ image_filter_draw_under_recurse(Evas *e, Evas_Object *obj, Evas_Object *stop, * Draw all visible objects intersecting an object which are _beneath_ it. */ static void -image_filter_draw_under(Evas *e, Evas_Object *stop, void *output, void *ctx, void *surface, int dx, int dy) +image_filter_draw_under(Evas *eo_e, Evas_Object *stop, void *output, void *ctx, void *surface, int dx, int dy) { Evas_Layer *lay; int x, y; @@ -2442,7 +2797,7 @@ image_filter_draw_under(Evas *e, Evas_Object *stop, void *output, void *ctx, voi EINA_INLIST_FOREACH(e->layers, lay) { - Evas_Object *obj; + Evas_Object *eo_obj; EINA_INLIST_FOREACH(lay->objects, obj) { if (obj->delete_me) continue; @@ -2462,7 +2817,7 @@ image_filter_draw_under(Evas *e, Evas_Object *stop, void *output, void *ctx, voi * Creates a new context, and renders stuff (filtered) onto that. */ Filtered_Image * -image_filter_update(Evas *e, Evas_Object *obj, void *src, int imagew, int imageh, int *outw, int *outh) +image_filter_update(Evas *eo_e, Evas_Object *eo_obj, void *src, int imagew, int imageh, int *outw, int *outh) { int w, h; void *ctx; @@ -2542,15 +2897,16 @@ image_filter_update(Evas *e, Evas_Object *obj, void *src, int imagew, int imageh #endif static void -evas_object_image_unload(Evas_Object *obj, Eina_Bool dirty) +evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty) { Evas_Object_Image *o; Eina_Bool resize_call = EINA_FALSE; - o = (Evas_Object_Image *)(obj->object_data); - + o = eo_data_get(eo_obj, MY_CLASS); if ((!o->cur.file) || (o->pixels_checked_out > 0)) return; + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (dirty) { if (o->engine_data) @@ -2567,7 +2923,7 @@ evas_object_image_unload(Evas_Object *obj, Eina_Bool dirty) o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output, o->engine_data); @@ -2580,18 +2936,18 @@ evas_object_image_unload(Evas_Object *obj, Eina_Bool dirty) o->cur.image.w = 0; o->cur.image.h = 0; o->cur.image.stride = 0; - if (resize_call) evas_object_inform_call_image_resize(obj); + if (resize_call) evas_object_inform_call_image_resize(eo_obj); } static void -evas_object_image_load(Evas_Object *obj) +evas_object_image_load(Evas_Object *eo_obj) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); Evas_Image_Load_Opts lo; - o = (Evas_Object_Image *)(obj->object_data); if (o->engine_data) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); lo.scale_down_by = o->load_opts.scale_down_by; lo.dpi = o->load_opts.dpi; lo.w = o->load_opts.w; @@ -2633,7 +2989,7 @@ evas_object_image_load(Evas_Object *obj) o->cur.image.w = w; o->cur.image.h = h; o->cur.image.stride = stride; - if (resize_call) evas_object_inform_call_image_resize(obj); + if (resize_call) evas_object_inform_call_image_resize(eo_obj); } else { @@ -2642,7 +2998,7 @@ evas_object_image_load(Evas_Object *obj) } static Evas_Coord -evas_object_image_figure_x_fill(Evas_Object *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret) +evas_object_image_figure_x_fill(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret) { Evas_Coord w; @@ -2664,7 +3020,7 @@ evas_object_image_figure_x_fill(Evas_Object *obj, Evas_Coord start, Evas_Coord s } static Evas_Coord -evas_object_image_figure_y_fill(Evas_Object *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret) +evas_object_image_figure_y_fill(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret) { Evas_Coord h; @@ -2686,10 +3042,10 @@ evas_object_image_figure_y_fill(Evas_Object *obj, Evas_Coord start, Evas_Coord s } static void -evas_object_image_init(Evas_Object *obj) +evas_object_image_init(Evas_Object *eo_obj) { - /* alloc image ob, setup methods and default values */ - obj->object_data = evas_object_image_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_image_new(eo_obj); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -2709,17 +3065,10 @@ evas_object_image_init(Evas_Object *obj) obj->type = o_type; } -static void * -evas_object_image_new(void) +static void +evas_object_image_new(Evas_Object *eo_obj) { - Evas_Object_Image *o; - - /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_image", Evas_Object_Image, 16, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Image); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Image); - o->magic = MAGIC_OBJ_IMAGE; + Evas_Object_Image *o = eo_data_get(eo_obj, EVAS_OBJ_IMAGE_CLASS); o->cur.fill.w = 0; o->cur.fill.h = 0; o->cur.smooth_scale = 1; @@ -2731,25 +3080,27 @@ evas_object_image_new(void) o->cur.source = NULL; o->prev = o->cur; o->tmpf_fd = -1; - return o; } static void -evas_object_image_free(Evas_Object *obj) +_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - Evas_Object_Image *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_image_free(eo_obj, obj); + eo_do_super(eo_obj, eo_destructor()); +} + +static void +evas_object_image_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) +{ + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); Eina_Rectangle *r; - /* frees private object data. very simple here */ - o = (Evas_Object_Image *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return; - MAGIC_CHECK_END(); /* free obj */ - _cleanup_tmpf(obj); + _cleanup_tmpf(eo_obj); if (o->cur.file) eina_stringshare_del(o->cur.file); if (o->cur.key) eina_stringshare_del(o->cur.key); - if (o->cur.source) _proxy_unset(obj); + if (o->cur.source) _proxy_unset(eo_obj); if (o->engine_data) { if (o->preloading) @@ -2757,7 +3108,7 @@ evas_object_image_free(Evas_Object *obj) o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, - obj); + eo_obj); } obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output, o->engine_data); @@ -2765,32 +3116,27 @@ evas_object_image_free(Evas_Object *obj) if (o->video_surface) { o->video_surface = EINA_FALSE; - obj->layer->evas->video_objects = eina_list_remove(obj->layer->evas->video_objects, obj); + obj->layer->evas->video_objects = eina_list_remove(obj->layer->evas->video_objects, eo_obj); } o->engine_data = NULL; - o->magic = 0; EINA_LIST_FREE(o->pixel_updates, r) eina_rectangle_free(r); - EVAS_MEMPOOL_FREE(_mp_obj, o); } static void -evas_object_image_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); int imagew, imageh, uvw, uvh; void *pixels; - /* render object to surface with context, and offset by x,y */ - o = (Evas_Object_Image *)(obj->object_data); - if ((o->cur.fill.w < 1) || (o->cur.fill.h < 1)) return; /* no error message, already printed in pre_render */ /* Proxy sanity */ if (o->proxyrendering) { - _proxy_error(obj, context, output, surface, x, y); + _proxy_error(eo_obj, context, output, surface, x, y); return; } @@ -2839,6 +3185,10 @@ evas_object_image_render(Evas_Object *obj, void *output, void *context, void *su obj->layer->evas->engine.func->context_render_op_set(output, context, obj->cur.render_op); + Evas_Object_Protected_Data *source = + (o->cur.source ? + eo_data_get(o->cur.source, EVAS_OBJ_CLASS): + NULL); if (!o->cur.source) { pixels = o->engine_data; @@ -2847,32 +3197,32 @@ evas_object_image_render(Evas_Object *obj, void *output, void *context, void *su uvw = imagew; uvh = imageh; } - else if (o->cur.source->proxy.surface && !o->cur.source->proxy.redraw) + else if (source->proxy.surface && !source->proxy.redraw) { - pixels = o->cur.source->proxy.surface; - imagew = o->cur.source->proxy.w; - imageh = o->cur.source->proxy.h; + pixels = source->proxy.surface; + imagew = source->proxy.w; + imageh = source->proxy.h; uvw = imagew; uvh = imageh; } - else if (o->cur.source->type == o_type && - ((Evas_Object_Image *)o->cur.source->object_data)->engine_data) + else if (source->type == o_type && + ((Evas_Object_Image *)eo_data_get(o->cur.source, MY_CLASS))->engine_data) { Evas_Object_Image *oi; - oi = o->cur.source->object_data; + oi = eo_data_get(o->cur.source, MY_CLASS); pixels = oi->engine_data; imagew = oi->cur.image.w; imageh = oi->cur.image.h; - uvw = o->cur.source->cur.geometry.w; - uvh = o->cur.source->cur.geometry.h; + uvw = source->cur.geometry.w; + uvh = source->cur.geometry.h; } else { o->proxyrendering = EINA_TRUE; - _proxy_subrender(obj->layer->evas, o->cur.source); - pixels = o->cur.source->proxy.surface; - imagew = o->cur.source->proxy.w; - imageh = o->cur.source->proxy.h; + _proxy_subrender(obj->layer->evas->evas, o->cur.source); + pixels = source->proxy.surface; + imagew = source->proxy.w; + imageh = source->proxy.h; uvw = imagew; uvh = imageh; o->proxyrendering = EINA_FALSE; @@ -2953,12 +3303,12 @@ evas_object_image_render(Evas_Object *obj, void *output, void *context, void *su { if (obj->layer->evas->engine.func->gl_img_obj_set) { - obj->layer->evas->engine.func->gl_img_obj_set(output, obj, o->cur.has_alpha); + obj->layer->evas->engine.func->gl_img_obj_set(output, eo_obj, o->cur.has_alpha); img_set = 1; } } - o->func.get_pixels(o->func.get_pixels_data, obj); + o->func.get_pixels(o->func.get_pixels_data, eo_obj); if (o->engine_data != pixels) pixels = o->engine_data; o->engine_data = obj->layer->evas->engine.func->image_dirty_region @@ -2969,7 +3319,7 @@ evas_object_image_render(Evas_Object *obj, void *output, void *context, void *su } if ((obj->cur.map) && (obj->cur.map->count > 3) && (obj->cur.usemap)) { - evas_object_map_update(obj, x, y, imagew, imageh, uvw, uvh); + evas_object_map_update(eo_obj, x, y, imagew, imageh, uvw, uvh); obj->layer->evas->engine.func->image_map_draw (output, context, surface, pixels, obj->spans, @@ -2986,8 +3336,8 @@ evas_object_image_render(Evas_Object *obj, void *output, void *context, void *su obj->layer->evas->engine.func->image_border_set(output, pixels, o->cur.border.l, o->cur.border.r, o->cur.border.t, o->cur.border.b); - idx = evas_object_image_figure_x_fill(obj, o->cur.fill.x, o->cur.fill.w, &idw); - idy = evas_object_image_figure_y_fill(obj, o->cur.fill.y, o->cur.fill.h, &idh); + idx = evas_object_image_figure_x_fill(eo_obj, obj, o->cur.fill.x, o->cur.fill.w, &idw); + idy = evas_object_image_figure_y_fill(eo_obj, obj, o->cur.fill.y, o->cur.fill.h, &idh); if (idw < 1) idw = 1; if (idh < 1) idh = 1; if (idx > 0) idx -= idw; @@ -3181,11 +3531,10 @@ evas_object_image_render(Evas_Object *obj, void *output, void *context, void *su } static void -evas_object_image_render_pre(Evas_Object *obj) +evas_object_image_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); int is_v = 0, was_v = 0; - Evas *e; /* dont pre-render the obj twice! */ if (obj->pre_render_done) return; @@ -3195,54 +3544,57 @@ evas_object_image_render_pre(Evas_Object *obj) /* elsewhere, decoding video etc. */ /* then when this is done the object needs to figure if it changed and */ /* if so what and where and add the appropriate redraw rectangles */ - o = (Evas_Object_Image *)(obj->object_data); - e = obj->layer->evas; + Evas_Public_Data *e = obj->layer->evas; if ((o->cur.fill.w < 1) || (o->cur.fill.h < 1)) { ERR("%p has invalid fill size: %dx%d. Ignored", - obj, o->cur.fill.w, o->cur.fill.h); + eo_obj, o->cur.fill.w, o->cur.fill.h); return; } /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { - if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + Evas_Object_Protected_Data *clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + if (obj->cur.cache.clip.dirty) + evas_object_clip_recalc(obj->cur.clipper, clipper); + clipper->func->render_pre(obj->cur.clipper, clipper); } /* Proxy: Do it early */ - if (o->cur.source && - (o->cur.source->proxy.redraw || o->cur.source->changed)) + if (o->cur.source) { - /* XXX: Do I need to sort out the map here? */ - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); - goto done; + Evas_Object_Protected_Data *source = eo_data_get(o->cur.source, EVAS_OBJ_CLASS); + if (source->proxy.redraw || source->changed) + { + /* XXX: Do I need to sort out the map here? */ + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); + goto done; + } } /* now figure what changed and add draw rects */ /* if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); if (is_v != was_v) { - evas_object_render_pre_visible_change(&e->clip_changes, obj, is_v, was_v); + evas_object_render_pre_visible_change(&e->clip_changes, eo_obj, is_v, was_v); if (!o->pixel_updates) goto done; } if (obj->changed_map) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); goto done; } /* it's not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&e->clip_changes, obj); + evas_object_render_pre_clipper_change(&e->clip_changes, eo_obj); /* if we restacked (layer or just within a layer) and don't clip anyone */ if (obj->restack) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } /* if it changed color */ @@ -3251,19 +3603,19 @@ evas_object_image_render_pre(Evas_Object *obj) (obj->cur.color.b != obj->prev.color.b) || (obj->cur.color.a != obj->prev.color.a)) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } /* if it changed render op */ if (obj->cur.render_op != obj->prev.render_op) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } /* if it changed anti_alias */ if (obj->cur.anti_alias != obj->prev.anti_alias) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if (o->changed) @@ -3274,7 +3626,7 @@ evas_object_image_render_pre(Evas_Object *obj) ((!o->cur.key) && (o->prev.key)) ) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if ((o->cur.image.w != o->prev.image.w) || @@ -3283,7 +3635,7 @@ evas_object_image_render_pre(Evas_Object *obj) (o->cur.cspace != o->prev.cspace) || (o->cur.smooth_scale != o->prev.smooth_scale)) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if ((o->cur.border.l != o->prev.border.l) || @@ -3293,17 +3645,17 @@ evas_object_image_render_pre(Evas_Object *obj) (o->cur.border.fill != o->prev.border.fill) || (o->cur.border.scale != o->prev.border.scale)) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if (o->dirty_pixels) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if (o->cur.frame != o->prev.frame) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } @@ -3341,7 +3693,7 @@ evas_object_image_render_pre(Evas_Object *obj) (obj->cur.geometry.h != obj->prev.geometry.h)) ) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if (o->changed) @@ -3351,7 +3703,7 @@ evas_object_image_render_pre(Evas_Object *obj) (o->cur.fill.w != o->prev.fill.w) || (o->cur.fill.h != o->prev.fill.h)) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); if (!o->pixel_updates) goto done; } if (o->pixel_updates) @@ -3373,8 +3725,8 @@ evas_object_image_render_pre(Evas_Object *obj) e->engine.func->image_dirty_region(e->engine.data.output, o->engine_data, rr->x, rr->y, rr->w, rr->h); - idx = evas_object_image_figure_x_fill(obj, o->cur.fill.x, o->cur.fill.w, &idw); - idy = evas_object_image_figure_y_fill(obj, o->cur.fill.y, o->cur.fill.h, &idh); + idx = evas_object_image_figure_x_fill(eo_obj, obj, o->cur.fill.x, o->cur.fill.w, &idw); + idy = evas_object_image_figure_y_fill(eo_obj, obj, o->cur.fill.y, o->cur.fill.h, &idh); if (idw < 1) idw = 1; if (idh < 1) idh = 1; @@ -3419,11 +3771,11 @@ evas_object_image_render_pre(Evas_Object *obj) EINA_LIST_FREE(o->pixel_updates, r) eina_rectangle_free(r); - e->engine.func->image_dirty_region(e->engine.data.output, o->engine_data, 0, 0, o->cur.image.w, o->cur.image.h); - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); - goto done; - } - } + e->engine.func->image_dirty_region(e->engine.data.output, o->engine_data, 0, 0, o->cur.image.w, o->cur.image.h); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); + goto done; + } + } } #if 0 // filtering disabled if (obj->filter && obj->filter->dirty) @@ -3434,8 +3786,8 @@ evas_object_image_render_pre(Evas_Object *obj) /* it obviously didn't change - add a NO obscure - this "unupdates" this */ /* area so if there were updates for it they get wiped. don't do it if we */ /* aren't fully opaque and we are visible */ - if (evas_object_is_visible(obj) && - evas_object_is_opaque(obj)) + if (evas_object_is_visible(eo_obj, obj) && + evas_object_is_opaque(eo_obj, obj)) { Evas_Coord x, y, w, h; @@ -3445,75 +3797,68 @@ evas_object_image_render_pre(Evas_Object *obj) h = obj->cur.cache.clip.h; if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); RECTS_CLIP_TO_RECT(x, y, w, h, - obj->cur.clipper->cur.cache.clip.x, - obj->cur.clipper->cur.cache.clip.y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x, + cur_clipper->cur.cache.clip.y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); } e->engine.func->output_redraws_rect_del(e->engine.data.output, x, y, w, h); } done: - evas_object_render_pre_effect_updates(&e->clip_changes, obj, is_v, was_v); + evas_object_render_pre_effect_updates(&e->clip_changes, eo_obj, is_v, was_v); } static void -evas_object_image_render_post(Evas_Object *obj) +evas_object_image_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); Eina_Rectangle *r; /* this moves the current data to the previous state parts of the object */ /* in whatever way is safest for the object. also if we don't need object */ /* data anymore we can free it if the object deems this is a good idea */ - o = (Evas_Object_Image *)(obj->object_data); /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); EINA_LIST_FREE(o->pixel_updates, r) eina_rectangle_free(r); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); o->prev = o->cur; o->changed = EINA_FALSE; /* FIXME: copy strings across */ } -static unsigned int evas_object_image_id_get(Evas_Object *obj) +static unsigned int evas_object_image_id_get(Evas_Object *eo_obj) { - Evas_Object_Image *o; - - o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_IMAGE; } -static unsigned int evas_object_image_visual_id_get(Evas_Object *obj) +static unsigned int evas_object_image_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Image *o; - - o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_IMAGE; } -static void *evas_object_image_engine_data_get(Evas_Object *obj) +static void *evas_object_image_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Image *o; - - o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return NULL; return o->engine_data; } static int -evas_object_image_is_opaque(Evas_Object *obj) +evas_object_image_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); /* this returns 1 if the internal object data implies that the object is */ /* currently fully opaque over the entire rectangle it occupies */ - o = (Evas_Object_Image *)(obj->object_data); /* disable caching due tyo maps screwing with this o->cur.opaque_valid = 0; if (o->cur.opaque_valid) @@ -3539,7 +3884,8 @@ evas_object_image_is_opaque(Evas_Object *obj) // FIXME: use proxy if (o->cur.source) { - o->cur.opaque = evas_object_is_opaque(o->cur.source); + Evas_Object_Protected_Data *cur_source = eo_data_get(o->cur.source, EVAS_OBJ_CLASS); + o->cur.opaque = evas_object_is_opaque(o->cur.source, cur_source); return o->cur.opaque; /* FIXME: Should go poke at the object */ } if (o->cur.has_alpha) @@ -3583,13 +3929,12 @@ evas_object_image_is_opaque(Evas_Object *obj) } static int -evas_object_image_was_opaque(Evas_Object *obj) +evas_object_image_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); /* this returns 1 if the internal object data implies that the object was */ /* previously fully opaque over the entire rectangle it occupies */ - o = (Evas_Object_Image *)(obj->object_data); if (o->prev.opaque_valid) { if (!o->prev.opaque) return 0; @@ -3618,16 +3963,14 @@ evas_object_image_was_opaque(Evas_Object *obj) } static int -evas_object_image_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_image_is_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); DATA32 *data; int w, h, stride, iw, ih; int a; int return_value; - o = (Evas_Object_Image *)(obj->object_data); - x -= obj->cur.cache.clip.x; y -= obj->cur.cache.clip.y; w = obj->cur.cache.clip.w; @@ -3764,11 +4107,10 @@ evas_object_image_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y) } static int -evas_object_image_has_opaque_rect(Evas_Object *obj) +evas_object_image_has_opaque_rect(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); - o = (Evas_Object_Image *)(obj->object_data); if ((obj->cur.map) && (obj->cur.usemap)) return 0; if (((o->cur.border.l | o->cur.border.r | o->cur.border.t | o->cur.border.b) != 0) && (o->cur.border.fill == EVAS_BORDER_FILL_SOLID) && @@ -3783,11 +4125,10 @@ evas_object_image_has_opaque_rect(Evas_Object *obj) } static int -evas_object_image_get_opaque_rect(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) +evas_object_image_get_opaque_rect(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - Evas_Object_Image *o; + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); - o = (Evas_Object_Image *)(obj->object_data); if (o->cur.border.scale == 1.0) { *x = obj->cur.geometry.x + o->cur.border.l; @@ -3884,56 +4225,53 @@ evas_object_image_filled_resize_listener(void *data __UNUSED__, Evas *e __UNUSED Eina_Bool -_evas_object_image_preloading_get(const Evas_Object *obj) +_evas_object_image_preloading_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o = (Evas_Object_Image *)(obj->object_data); - if (!o) return EINA_FALSE; - MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE); - return EINA_FALSE; - MAGIC_CHECK_END(); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); return o->preloading; } void -_evas_object_image_preloading_set(Evas_Object *obj, Eina_Bool preloading) +_evas_object_image_preloading_set(Evas_Object *eo_obj, Eina_Bool preloading) { - Evas_Object_Image *o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); o->preloading = preloading; } void -_evas_object_image_preloading_check(Evas_Object *obj) +_evas_object_image_preloading_check(Evas_Object *eo_obj) { - Evas_Object_Image *o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); if (obj->layer->evas->engine.func->image_load_error_get) o->load_error = obj->layer->evas->engine.func->image_load_error_get (obj->layer->evas->engine.data.output, o->engine_data); } Evas_Object * -_evas_object_image_video_parent_get(Evas_Object *obj) +_evas_object_image_video_parent_get(Evas_Object *eo_obj) { - Evas_Object_Image *o = (Evas_Object_Image *)(obj->object_data); - + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); return o->video_surface ? o->video.parent : NULL; } void -_evas_object_image_video_overlay_show(Evas_Object *obj) +_evas_object_image_video_overlay_show(Evas_Object *eo_obj) { - Evas_Object_Image *o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); if (obj->cur.cache.clip.x != obj->prev.cache.clip.x || obj->cur.cache.clip.y != obj->prev.cache.clip.y || o->created || !o->video_visible) - o->video.move(o->video.data, obj, &o->video, obj->cur.cache.clip.x, obj->cur.cache.clip.y); + o->video.move(o->video.data, eo_obj, &o->video, obj->cur.cache.clip.x, obj->cur.cache.clip.y); if (obj->cur.cache.clip.w != obj->prev.cache.clip.w || obj->cur.cache.clip.h != obj->prev.cache.clip.h || o->created || !o->video_visible) - o->video.resize(o->video.data, obj, &o->video, obj->cur.cache.clip.w, obj->cur.cache.clip.h); + o->video.resize(o->video.data, eo_obj, &o->video, obj->cur.cache.clip.w, obj->cur.cache.clip.h); if (!o->video_visible || o->created) { - o->video.show(o->video.data, obj, &o->video); + o->video.show(o->video.data, eo_obj, &o->video); } else { @@ -3949,16 +4287,174 @@ _evas_object_image_video_overlay_show(Evas_Object *obj) } void -_evas_object_image_video_overlay_hide(Evas_Object *obj) +_evas_object_image_video_overlay_hide(Evas_Object *eo_obj) { - Evas_Object_Image *o = (Evas_Object_Image *)(obj->object_data); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Image *o = eo_data_get(eo_obj, MY_CLASS); if (o->video_visible || o->created) - o->video.hide(o->video.data, obj, &o->video); - if (evas_object_is_visible(obj)) - o->video.update_pixels(o->video.data, obj, &o->video); + o->video.hide(o->video.data, eo_obj, &o->video); + if (evas_object_is_visible(eo_obj, obj)) + o->video.update_pixels(o->video.data, eo_obj, &o->video); o->video_visible = EINA_FALSE; o->created = EINA_FALSE; } +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_MEMFILE_SET), _image_memfile_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILE_SET), _image_file_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILE_GET), _image_file_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_SET), _image_source_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_GET), _image_source_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SET), _image_border_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_GET), _image_border_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_SET), _image_border_center_fill_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_GET), _image_border_center_fill_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILLED_SET), _image_filled_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILLED_GET), _image_filled_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_SET), _image_border_scale_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_GET), _image_border_scale_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SET), _image_fill_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_GET), _image_fill_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_SET), _image_fill_spread_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_GET), _image_fill_spread_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SIZE_SET), _image_size_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SIZE_GET), _image_size_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_STRIDE_GET), _image_stride_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ERROR_GET), _image_load_error_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_CONVERT), _image_data_convert), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_SET), _image_data_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_GET), _image_data_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD), _image_preload), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_COPY_SET), _image_data_copy_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_UPDATE_ADD), _image_data_update_add), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_SET), _image_alpha_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_GET), _image_alpha_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_SET), _image_smooth_scale_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_GET), _image_smooth_scale_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_RELOAD), _image_reload), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SAVE), _image_save), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_IMPORT), _image_pixels_import), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_GET_CALLBACK_SET), _image_pixels_get_callback_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_SET), _image_pixels_dirty_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_GET), _image_pixels_dirty_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_SET), _image_load_dpi_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_GET), _image_load_dpi_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_SET), _image_load_size_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_GET), _image_load_size_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_SET), _image_load_scale_down_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_GET), _image_load_scale_down_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_SET), _image_load_region_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_GET), _image_load_region_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_SET), _image_load_orientation_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_GET), _image_load_orientation_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_SET), _image_colorspace_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_GET), _image_colorspace_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_SET), _image_video_surface_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_GET), _image_video_surface_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_SET), _image_native_surface_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_GET), _image_native_surface_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_SET), _image_scale_hint_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_GET), _image_scale_hint_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_SET), _image_content_hint_set), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_GET), _image_content_hint_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_REGION_SUPPORT_GET), _image_region_support_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_GET), _image_animated_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_COUNT_GET), _image_animated_frame_count_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_TYPE_GET), _image_animated_loop_type_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_COUNT_GET), _image_animated_loop_count_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_DURATION_GET), _image_animated_frame_duration_get), + EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET), _image_animated_frame_set), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_MEMFILE_SET, "Sets the data for an image from memory to be loaded"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILE_SET, "Set the source file from where an image object must fetch the real"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILE_GET, "Retrieve the source file from where an image object is to fetch the"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_SET, "Set the source object on an image object to used as a @b proxy."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_GET, "Get the current source object of an image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SET, "Set the dimensions for an image object's border."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_GET, "Retrieve the dimensions for an image object's border, a region."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_SET, "Sets how the center part of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_GET, "Retrieves how the center part of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILLED_SET, "Set whether the image object's fill property should track the object's size."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILLED_GET, "Retrieve whether the image object's fill property should track the object's size."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_SET, "Sets the scaling factor (multiplier) for the borders of an image object"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_GET, "Retrieves the scaling factor (multiplier) for the borders of an image object"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_SET, "Set how to fill an image object's drawing rectangle given the (real) image bound to it."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_GET, "Retrieve how an image object is to fill its drawing rectangle, given the (real) image bound to it."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_SET, "Sets the tiling mode for the given evas image object's fill."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_GET, "Retrieves the spread (tiling mode) for the given image object's fill."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SIZE_SET, "Sets the size of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SIZE_GET, "Retrieves the size of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_STRIDE_GET, "Retrieves the row stride of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ERROR_GET, "Retrieves a number representing any error."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_CONVERT, "Converts the raw image data of the given image object to the specified colorspace."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_SET, "Sets the raw image data of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_GET, "Get a pointer to the raw image data of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD, "Preload an image object's image data in the background."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_COPY_SET, "Replaces the raw image data of the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_UPDATE_ADD, "Mark a sub-region of the given image object to be redrawn."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_SET, "Enable or disable alpha channel usage on the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_GET, "Retrieve whether alpha channel data is being used on the given image object"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_SET, "Sets whether to use high-quality image scaling algorithm on the given image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_GET, "Retrieves whether the given image object is using high-quality image scaling algorithm."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_RELOAD, "Reload an image object's image data."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SAVE, "Save the given image object's contents to an (image) file."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_IMPORT, "Import pixels from given source to a given canvas image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_GET_CALLBACK_SET, "Set the callback function to get pixels from a canvas' image."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_SET, "Mark whether the given image object is dirty and needs to request its pixels."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_GET, "Retrieves whether the given image object is dirty (needs to be redrawn)."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_SET, "Set the DPI resolution of an image object's source image."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_GET, "Get the DPI resolution of a loaded image object in the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_SET, "Set the size of a given image object's source image, when loading it."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_GET, "Get the size of a given image object's source image, when loading it."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_SET, "Set the scale down factor of a given image object's source image, when loading it."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_GET, "get the scale down factor of a given image object's source image, when loading it."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_SET, "Inform a given image object to load a selective region of its source image."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_GET, "Retrieve the coordinates of a given image object's selective load region."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_SET, "Define if the orientation information in the image file should be honored."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_GET, "Get if the orientation information in the image file should be honored."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_SET, "Set the colorspace of a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_GET, "Get the colorspace of a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_SET, "Set the video surface linked to a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_GET, "Get the video surface linekd to a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_SET, "Set the native surface of a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_GET, "Get the native surface of a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_SET, "Set the scale hint of a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_GET, "Get the scale hint of a given image of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_SET, "Set the content hint setting of a given image object of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_GET, "Get the content hint setting of a given image object of the canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_REGION_SUPPORT_GET, "Get the support state of a given image"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_GET, "Check if an image object can be animated (have multiple frames)"), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_COUNT_GET, "Get the total number of frames of the image object."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_TYPE_GET, "Get the kind of looping the image object does."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_COUNT_GET, "Get the number times the animation of the object loops."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_DURATION_GET, "Get the duration of a sequence of frames."), + EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET, "Set the frame to current frame of an image object."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Image", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_IMAGE_BASE_ID, op_desc, EVAS_OBJ_IMAGE_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Image), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_image_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); + /* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/ diff --git a/legacy/evas/src/lib/canvas/evas_object_inform.c b/legacy/evas/src/lib/canvas/evas_object_inform.c index ef1328f627..848012d98b 100644 --- a/legacy/evas/src/lib/canvas/evas_object_inform.c +++ b/legacy/evas/src/lib/canvas/evas_object_inform.c @@ -4,84 +4,92 @@ /* local calls */ void -evas_object_inform_call_show(Evas_Object *obj) +evas_object_inform_call_show(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_SHOW, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_SHOW, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_hide(Evas_Object *obj) +evas_object_inform_call_hide(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_HIDE, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_HIDE, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_move(Evas_Object *obj) +evas_object_inform_call_move(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOVE, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOVE, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_resize(Evas_Object *obj) +evas_object_inform_call_resize(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_RESIZE, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_RESIZE, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_restack(Evas_Object *obj) +evas_object_inform_call_restack(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_RESTACK, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_RESTACK, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_changed_size_hints(Evas_Object *obj) +evas_object_inform_call_changed_size_hints(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_image_preloaded(Evas_Object *obj) +evas_object_inform_call_image_preloaded(Evas_Object *eo_obj) { - if (!_evas_object_image_preloading_get(obj)) return; - _evas_object_image_preloading_check(obj); - _evas_object_image_preloading_set(obj, 0); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!_evas_object_image_preloading_get(eo_obj)) return; + _evas_object_image_preloading_check(eo_obj); + _evas_object_image_preloading_set(eo_obj, 0); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_image_unloaded(Evas_Object *obj) +evas_object_inform_call_image_unloaded(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_IMAGE_UNLOADED, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_UNLOADED, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } void -evas_object_inform_call_image_resize(Evas_Object *obj) +evas_object_inform_call_image_resize(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_IMAGE_RESIZE, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_RESIZE, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } diff --git a/legacy/evas/src/lib/canvas/evas_object_intercept.c b/legacy/evas/src/lib/canvas/evas_object_intercept.c index 54f7265744..4c31cd8628 100644 --- a/legacy/evas/src/lib/canvas/evas_object_intercept.c +++ b/legacy/evas/src/lib/canvas/evas_object_intercept.c @@ -3,19 +3,21 @@ /* local calls */ -static void evas_object_intercept_init(Evas_Object *obj); -static void evas_object_intercept_deinit(Evas_Object *obj); +static void evas_object_intercept_init(Evas_Object *eo_obj); +static void evas_object_intercept_deinit(Evas_Object *eo_obj); static void -evas_object_intercept_init(Evas_Object *obj) +evas_object_intercept_init(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->interceptors) obj->interceptors = evas_mem_calloc(sizeof(Evas_Intercept_Func)); } static void -evas_object_intercept_deinit(Evas_Object *obj) +evas_object_intercept_deinit(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->interceptors) return; if ((obj->interceptors->show.func) || (obj->interceptors->hide.func) || @@ -37,14 +39,16 @@ evas_object_intercept_deinit(Evas_Object *obj) /* private calls */ void -evas_object_intercept_cleanup(Evas_Object *obj) +evas_object_intercept_cleanup(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (obj->interceptors) free(obj->interceptors); } int -evas_object_intercept_call_show(Evas_Object *obj) +evas_object_intercept_call_show(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -52,14 +56,15 @@ evas_object_intercept_call_show(Evas_Object *obj) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->show.func); if (ret) - obj->interceptors->show.func(obj->interceptors->show.data, obj); + obj->interceptors->show.func(obj->interceptors->show.data, eo_obj); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_hide(Evas_Object *obj) +evas_object_intercept_call_hide(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -67,13 +72,13 @@ evas_object_intercept_call_hide(Evas_Object *obj) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->hide.func); if (ret) - obj->interceptors->hide.func(obj->interceptors->hide.data, obj); + obj->interceptors->hide.func(obj->interceptors->hide.data, eo_obj); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_intercept_call_move(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y) { int ret; @@ -82,14 +87,15 @@ evas_object_intercept_call_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->move.func); if (ret) - obj->interceptors->move.func(obj->interceptors->move.data, obj, x, y); + obj->interceptors->move.func(obj->interceptors->move.data, eo_obj, x, y); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h) +evas_object_intercept_call_resize(Evas_Object *eo_obj, Evas_Coord w, Evas_Coord h) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -97,14 +103,15 @@ evas_object_intercept_call_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->resize.func); if (ret) - obj->interceptors->resize.func(obj->interceptors->resize.data, obj, w, h); + obj->interceptors->resize.func(obj->interceptors->resize.data, eo_obj, w, h); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_raise(Evas_Object *obj) +evas_object_intercept_call_raise(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -112,14 +119,15 @@ evas_object_intercept_call_raise(Evas_Object *obj) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->raise.func); if (ret) - obj->interceptors->raise.func(obj->interceptors->raise.data, obj); + obj->interceptors->raise.func(obj->interceptors->raise.data, eo_obj); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_lower(Evas_Object *obj) +evas_object_intercept_call_lower(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -127,14 +135,15 @@ evas_object_intercept_call_lower(Evas_Object *obj) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->lower.func); if (ret) - obj->interceptors->lower.func(obj->interceptors->lower.data, obj); + obj->interceptors->lower.func(obj->interceptors->lower.data, eo_obj); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_stack_above(Evas_Object *obj, Evas_Object *above) +evas_object_intercept_call_stack_above(Evas_Object *eo_obj, Evas_Object *above) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -142,14 +151,15 @@ evas_object_intercept_call_stack_above(Evas_Object *obj, Evas_Object *above) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->stack_above.func); if (ret) - obj->interceptors->stack_above.func(obj->interceptors->stack_above.data, obj, above); + obj->interceptors->stack_above.func(obj->interceptors->stack_above.data, eo_obj, above); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_stack_below(Evas_Object *obj, Evas_Object *below) +evas_object_intercept_call_stack_below(Evas_Object *eo_obj, Evas_Object *below) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -157,14 +167,15 @@ evas_object_intercept_call_stack_below(Evas_Object *obj, Evas_Object *below) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->stack_below.func); if (ret) - obj->interceptors->stack_below.func(obj->interceptors->stack_below.data, obj, below); + obj->interceptors->stack_below.func(obj->interceptors->stack_below.data, eo_obj, below); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_layer_set(Evas_Object *obj, int l) +evas_object_intercept_call_layer_set(Evas_Object *eo_obj, int l) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -172,14 +183,15 @@ evas_object_intercept_call_layer_set(Evas_Object *obj, int l) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->layer_set.func); if (ret) - obj->interceptors->layer_set.func(obj->interceptors->layer_set.data, obj, l); + obj->interceptors->layer_set.func(obj->interceptors->layer_set.data, eo_obj, l); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_color_set(Evas_Object *obj, int r, int g, int b, int a) +evas_object_intercept_call_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -187,13 +199,13 @@ evas_object_intercept_call_color_set(Evas_Object *obj, int r, int g, int b, int obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->color_set.func); if (ret) - obj->interceptors->color_set.func(obj->interceptors->color_set.data, obj, r, g, b, a); + obj->interceptors->color_set.func(obj->interceptors->color_set.data, eo_obj, r, g, b, a); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_clip_set(Evas_Object *obj, Evas_Object *clip) +evas_object_intercept_call_clip_set(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object *clip) { int ret; @@ -202,14 +214,15 @@ evas_object_intercept_call_clip_set(Evas_Object *obj, Evas_Object *clip) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->clip_set.func); if (ret) - obj->interceptors->clip_set.func(obj->interceptors->clip_set.data, obj, clip); + obj->interceptors->clip_set.func(obj->interceptors->clip_set.data, eo_obj, clip); obj->intercepted = EINA_FALSE; return ret; } int -evas_object_intercept_call_clip_unset(Evas_Object *obj) +evas_object_intercept_call_clip_unset(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); int ret; if (!obj->interceptors) return 0; @@ -217,7 +230,7 @@ evas_object_intercept_call_clip_unset(Evas_Object *obj) obj->intercepted = EINA_TRUE; ret = !!(obj->interceptors->clip_unset.func); if (ret) - obj->interceptors->clip_unset.func(obj->interceptors->clip_unset.data, obj); + obj->interceptors->clip_unset.func(obj->interceptors->clip_unset.data, eo_obj); obj->intercepted = EINA_FALSE; return ret; } @@ -225,54 +238,58 @@ evas_object_intercept_call_clip_unset(Evas_Object *obj) /* public calls */ EAPI void -evas_object_intercept_show_callback_add(Evas_Object *obj, Evas_Object_Intercept_Show_Cb func, const void *data) +evas_object_intercept_show_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Show_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->show.func = func; obj->interceptors->show.data = (void *)data; } EAPI void * -evas_object_intercept_show_callback_del(Evas_Object *obj, Evas_Object_Intercept_Show_Cb func) +evas_object_intercept_show_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Show_Cb func) { void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return NULL; if (!obj->interceptors) return NULL; obj->interceptors->show.func = NULL; data = obj->interceptors->show.data; obj->interceptors->show.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_hide_callback_add(Evas_Object *obj, Evas_Object_Intercept_Hide_Cb func, const void *data) +evas_object_intercept_hide_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Hide_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->hide.func = func; obj->interceptors->hide.data = (void *)data; } EAPI void * -evas_object_intercept_hide_callback_del(Evas_Object *obj, Evas_Object_Intercept_Hide_Cb func) +evas_object_intercept_hide_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Hide_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -280,29 +297,31 @@ evas_object_intercept_hide_callback_del(Evas_Object *obj, Evas_Object_Intercept_ obj->interceptors->hide.func = NULL; data = obj->interceptors->hide.data; obj->interceptors->hide.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_move_callback_add(Evas_Object *obj, Evas_Object_Intercept_Move_Cb func, const void *data) +evas_object_intercept_move_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Move_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->move.func = func; obj->interceptors->move.data = (void *)data; } EAPI void * -evas_object_intercept_move_callback_del(Evas_Object *obj, Evas_Object_Intercept_Move_Cb func) +evas_object_intercept_move_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Move_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -310,29 +329,31 @@ evas_object_intercept_move_callback_del(Evas_Object *obj, Evas_Object_Intercept_ obj->interceptors->move.func = NULL; data = obj->interceptors->move.data; obj->interceptors->move.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_resize_callback_add(Evas_Object *obj, Evas_Object_Intercept_Resize_Cb func, const void *data) +evas_object_intercept_resize_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Resize_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->resize.func = func; obj->interceptors->resize.data = (void *)data; } EAPI void * -evas_object_intercept_resize_callback_del(Evas_Object *obj, Evas_Object_Intercept_Resize_Cb func) +evas_object_intercept_resize_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Resize_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -340,29 +361,31 @@ evas_object_intercept_resize_callback_del(Evas_Object *obj, Evas_Object_Intercep obj->interceptors->resize.func = NULL; data = obj->interceptors->resize.data; obj->interceptors->resize.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_raise_callback_add(Evas_Object *obj, Evas_Object_Intercept_Raise_Cb func, const void *data) +evas_object_intercept_raise_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Raise_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->raise.func = func; obj->interceptors->raise.data = (void *)data; } EAPI void * -evas_object_intercept_raise_callback_del(Evas_Object *obj, Evas_Object_Intercept_Raise_Cb func) +evas_object_intercept_raise_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Raise_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -370,29 +393,31 @@ evas_object_intercept_raise_callback_del(Evas_Object *obj, Evas_Object_Intercept obj->interceptors->raise.func = NULL; data = obj->interceptors->raise.data; obj->interceptors->raise.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_lower_callback_add(Evas_Object *obj, Evas_Object_Intercept_Lower_Cb func, const void *data) +evas_object_intercept_lower_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Lower_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->lower.func = func; obj->interceptors->lower.data = (void *)data; } EAPI void * -evas_object_intercept_lower_callback_del(Evas_Object *obj, Evas_Object_Intercept_Lower_Cb func) +evas_object_intercept_lower_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Lower_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -400,29 +425,31 @@ evas_object_intercept_lower_callback_del(Evas_Object *obj, Evas_Object_Intercept obj->interceptors->lower.func = NULL; data = obj->interceptors->lower.data; obj->interceptors->lower.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_stack_above_callback_add(Evas_Object *obj, Evas_Object_Intercept_Stack_Above_Cb func, const void *data) +evas_object_intercept_stack_above_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Stack_Above_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->stack_above.func = func; obj->interceptors->stack_above.data = (void *)data; } EAPI void * -evas_object_intercept_stack_above_callback_del(Evas_Object *obj, Evas_Object_Intercept_Stack_Above_Cb func) +evas_object_intercept_stack_above_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Stack_Above_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -430,29 +457,31 @@ evas_object_intercept_stack_above_callback_del(Evas_Object *obj, Evas_Object_Int obj->interceptors->stack_above.func = NULL; data = obj->interceptors->stack_above.data; obj->interceptors->stack_above.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_stack_below_callback_add(Evas_Object *obj, Evas_Object_Intercept_Stack_Below_Cb func, const void *data) +evas_object_intercept_stack_below_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Stack_Below_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->stack_below.func = func; obj->interceptors->stack_below.data = (void *)data; } EAPI void * -evas_object_intercept_stack_below_callback_del(Evas_Object *obj, Evas_Object_Intercept_Stack_Below_Cb func) +evas_object_intercept_stack_below_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Stack_Below_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -460,29 +489,31 @@ evas_object_intercept_stack_below_callback_del(Evas_Object *obj, Evas_Object_Int obj->interceptors->stack_below.func = NULL; data = obj->interceptors->stack_below.data; obj->interceptors->stack_below.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_layer_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Layer_Set_Cb func, const void *data) +evas_object_intercept_layer_set_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Layer_Set_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->layer_set.func = func; obj->interceptors->layer_set.data = (void *)data; } EAPI void * -evas_object_intercept_layer_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Layer_Set_Cb func) +evas_object_intercept_layer_set_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Layer_Set_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -490,29 +521,31 @@ evas_object_intercept_layer_set_callback_del(Evas_Object *obj, Evas_Object_Inter obj->interceptors->layer_set.func = NULL; data = obj->interceptors->layer_set.data; obj->interceptors->layer_set.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_color_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Color_Set_Cb func, const void *data) +evas_object_intercept_color_set_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Color_Set_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->color_set.func = func; obj->interceptors->color_set.data = (void *)data; } EAPI void * -evas_object_intercept_color_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Color_Set_Cb func) +evas_object_intercept_color_set_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Color_Set_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -520,29 +553,31 @@ evas_object_intercept_color_set_callback_del(Evas_Object *obj, Evas_Object_Inter obj->interceptors->color_set.func = NULL; data = obj->interceptors->color_set.data; obj->interceptors->color_set.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_clip_set_callback_add(Evas_Object *obj, Evas_Object_Intercept_Clip_Set_Cb func, const void *data) +evas_object_intercept_clip_set_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Clip_Set_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->clip_set.func = func; obj->interceptors->clip_set.data = (void *)data; } EAPI void * -evas_object_intercept_clip_set_callback_del(Evas_Object *obj, Evas_Object_Intercept_Clip_Set_Cb func) +evas_object_intercept_clip_set_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Clip_Set_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -550,29 +585,31 @@ evas_object_intercept_clip_set_callback_del(Evas_Object *obj, Evas_Object_Interc obj->interceptors->clip_set.func = NULL; data = obj->interceptors->clip_set.data; obj->interceptors->clip_set.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } EAPI void -evas_object_intercept_clip_unset_callback_add(Evas_Object *obj, Evas_Object_Intercept_Clip_Unset_Cb func, const void *data) +evas_object_intercept_clip_unset_callback_add(Evas_Object *eo_obj, Evas_Object_Intercept_Clip_Unset_Cb func, const void *data) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!func) return; - evas_object_intercept_init(obj); + evas_object_intercept_init(eo_obj); if (!obj->interceptors) return; obj->interceptors->clip_unset.func = func; obj->interceptors->clip_unset.data = (void *)data; } EAPI void * -evas_object_intercept_clip_unset_callback_del(Evas_Object *obj, Evas_Object_Intercept_Clip_Unset_Cb func) +evas_object_intercept_clip_unset_callback_del(Evas_Object *eo_obj, Evas_Object_Intercept_Clip_Unset_Cb func) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *data; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); if (!func) return NULL; @@ -580,6 +617,6 @@ evas_object_intercept_clip_unset_callback_del(Evas_Object *obj, Evas_Object_Inte obj->interceptors->clip_unset.func = NULL; data = obj->interceptors->clip_unset.data; obj->interceptors->clip_unset.data = NULL; - evas_object_intercept_deinit(obj); + evas_object_intercept_deinit(eo_obj); return data; } diff --git a/legacy/evas/src/lib/canvas/evas_object_line.c b/legacy/evas/src/lib/canvas/evas_object_line.c index 177421dc2f..8f7ed6eef7 100644 --- a/legacy/evas/src/lib/canvas/evas_object_line.c +++ b/legacy/evas/src/lib/canvas/evas_object_line.c @@ -1,6 +1,12 @@ #include "evas_common.h" #include "evas_private.h" +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_LINE_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_LINE_CLASS + /* private magic number for line objects */ static const char o_type[] = "line"; @@ -9,7 +15,6 @@ typedef struct _Evas_Object_Line Evas_Object_Line; struct _Evas_Object_Line { - DATA32 magic; struct { struct { Evas_Coord x1, y1, x2, y2; @@ -25,27 +30,25 @@ struct _Evas_Object_Line }; /* private methods for line objects */ -static void evas_object_line_init(Evas_Object *obj); -static void *evas_object_line_new(void); -static void evas_object_line_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_line_free(Evas_Object *obj); -static void evas_object_line_render_pre(Evas_Object *obj); -static void evas_object_line_render_post(Evas_Object *obj); +static void evas_object_line_init(Evas_Object *eo_obj); +static void evas_object_line_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_line_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_line_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_line_id_get(Evas_Object *obj); -static unsigned int evas_object_line_visual_id_get(Evas_Object *obj); -static void *evas_object_line_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_line_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_line_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_line_engine_data_get(Evas_Object *eo_obj); -static int evas_object_line_is_opaque(Evas_Object *obj); -static int evas_object_line_was_opaque(Evas_Object *obj); -static int evas_object_line_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); -static int evas_object_line_was_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); -static void evas_object_line_coords_recalc(Evas_Object *obj); +static int evas_object_line_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_line_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_line_is_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y); +static int evas_object_line_was_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y); +static void evas_object_line_coords_recalc(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_line_free, + NULL, evas_object_line_render, evas_object_line_render_pre, evas_object_line_render_post, @@ -71,43 +74,47 @@ static const Evas_Object_Func object_func = /* the actual api call to add a rect */ /* it has no other api calls as all properties are standard */ -EVAS_MEMPOOL(_mp_obj); - EAPI Evas_Object * evas_object_line_add(Evas *e) { - Evas_Object *obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - obj = evas_object_new(e); - evas_object_line_init(obj); - evas_object_inject(obj, e); - return obj; + Evas_Object *eo_obj = eo_add(EVAS_OBJ_LINE_CLASS, e); + eo_unref(eo_obj); + return eo_obj; } EAPI void -evas_object_line_xy_set(Evas_Object *obj, Evas_Coord x1, Evas_Coord y1, Evas_Coord x2, Evas_Coord y2) +evas_object_line_xy_set(Evas_Object *eo_obj, Evas_Coord x1, Evas_Coord y1, Evas_Coord x2, Evas_Coord y2) { - Evas_Object_Line *o; + eo_do(eo_obj, evas_obj_line_xy_set(x1, y1, x2, y2)); +} + +static void +_line_xy_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Coord x1 = va_arg(*list, Evas_Coord); + Evas_Coord y1 = va_arg(*list, Evas_Coord); + Evas_Coord x2 = va_arg(*list, Evas_Coord); + Evas_Coord y2 = va_arg(*list, Evas_Coord); + + Evas_Object_Line *o = _pd; Evas_Coord min_x, max_x, min_y, max_y; int is, was = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Line *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Line, MAGIC_OBJ_LINE); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); if ((x1 == o->cur.x1) && (y1 == o->cur.y1) && (x2 == o->cur.x2) && (y2 == o->cur.y2)) return; - if (obj->layer->evas->events_frozen <= 0) + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!(obj->layer->evas->is_frozen)) { - if (!evas_event_passes_through(obj) && - !evas_event_freezes_through(obj)) - was = evas_object_is_in_output_rect(obj, + if (!evas_event_passes_through(eo_obj, obj) && + !evas_event_freezes_through(eo_obj, obj)) + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); @@ -142,49 +149,53 @@ evas_object_line_xy_set(Evas_Object *obj, Evas_Coord x1, Evas_Coord y1, Evas_Coo o->cur.x2 = x2 - min_x; o->cur.y2 = y2 - min_y; o->changed = EINA_TRUE; - evas_object_change(obj); - evas_object_coords_recalc(obj); - evas_object_clip_dirty(obj); - if (obj->layer->evas->events_frozen <= 0) + evas_object_change(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + if (!(obj->layer->evas->is_frozen)) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); - if (!evas_event_passes_through(obj) && - !evas_event_freezes_through(obj)) + if (!evas_event_passes_through(eo_obj, obj) && + !evas_event_freezes_through(eo_obj, obj)) { if ((is ^ was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } } - evas_object_inform_call_move(obj); - evas_object_inform_call_resize(obj); + evas_object_inform_call_move(eo_obj, obj); + evas_object_inform_call_resize(eo_obj); } EAPI void -evas_object_line_xy_get(const Evas_Object *obj, Evas_Coord *x1, Evas_Coord *y1, Evas_Coord *x2, Evas_Coord *y2) +evas_object_line_xy_get(const Evas_Object *eo_obj, Evas_Coord *x1, Evas_Coord *y1, Evas_Coord *x2, Evas_Coord *y2) { - Evas_Object_Line *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (x1) *x1 = 0; + if (y1) *y1 = 0; + if (x2) *x2 = 0; + if (y2) *y2 = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_line_xy_get(x1, y1, x2, y2)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (x1) *x1 = 0; - if (y1) *y1 = 0; - if (x2) *x2 = 0; - if (y2) *y2 = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Line *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Line, MAGIC_OBJ_LINE); - if (x1) *x1 = 0; - if (y1) *y1 = 0; - if (x2) *x2 = 0; - if (y2) *y2 = 0; - return; - MAGIC_CHECK_END(); +static void +_line_xy_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Object_Line *o = _pd; + + Evas_Coord *x1 = va_arg(*list, Evas_Coord *); + Evas_Coord *y1 = va_arg(*list, Evas_Coord *); + Evas_Coord *x2 = va_arg(*list, Evas_Coord *); + Evas_Coord *y2 = va_arg(*list, Evas_Coord *); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (x1) *x1 = obj->cur.geometry.x + o->cur.x1; if (y1) *y1 = obj->cur.geometry.y + o->cur.y1; if (x2) *x2 = obj->cur.geometry.x + o->cur.x2; @@ -193,10 +204,9 @@ evas_object_line_xy_get(const Evas_Object *obj, Evas_Coord *x1, Evas_Coord *y1, /* all nice and private */ static void -evas_object_line_init(Evas_Object *obj) +evas_object_line_init(Evas_Object *eo_obj) { - /* alloc image ob, setup methods and default values */ - obj->object_data = evas_object_line_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -216,47 +226,37 @@ evas_object_line_init(Evas_Object *obj) obj->type = o_type; } -static void * -evas_object_line_new(void) +static void +_constructor(Eo *eo_obj, void *class_data, va_list *list EINA_UNUSED) { - Evas_Object_Line *o; + eo_do_super(eo_obj, eo_constructor()); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_line_init(eo_obj); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); + + Evas_Object_Line *o = class_data; /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_line", Evas_Object_Line, 4, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Line); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Line); - o->magic = MAGIC_OBJ_LINE; o->cur.x1 = 0; o->cur.y1 = 0; o->cur.x2 = 31; o->cur.y2 = 31; o->prev = o->cur; - return o; } static void -evas_object_line_free(Evas_Object *obj) +_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - Evas_Object_Line *o; - - /* frees private object data. very simple here */ - o = (Evas_Object_Line *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Line, MAGIC_OBJ_LINE); - return; - MAGIC_CHECK_END(); - /* free obj */ - o->magic = 0; - EVAS_MEMPOOL_FREE(_mp_obj, o); + eo_do_super(eo_obj, eo_destructor()); } static void -evas_object_line_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_line_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { - Evas_Object_Line *o; + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); /* render object to surface with context, and offxet by x,y */ - o = (Evas_Object_Line *)(obj->object_data); + obj->layer->evas->engine.func->context_color_set(output, context, obj->cur.cache.clip.r, @@ -279,9 +279,9 @@ evas_object_line_render(Evas_Object *obj, void *output, void *context, void *sur } static void -evas_object_line_render_pre(Evas_Object *obj) +evas_object_line_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Line *o; + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); int is_v, was_v; Eina_Bool changed_color = EINA_FALSE; @@ -293,34 +293,33 @@ evas_object_line_render_pre(Evas_Object *obj) /* elsewhere, decoding video etc. */ /* then when this is done the object needs to figure if it changed and */ /* if so what and where and add the appropriate redraw lines */ - o = (Evas_Object_Line *)(obj->object_data); /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { - if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + if (obj->cur.cache.clip.dirty) + evas_object_clip_recalc(obj->cur.clipper, cur_clipper); + cur_clipper->func->render_pre(obj->cur.clipper, cur_clipper); } /* now figure what changed and add draw rects */ /* if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); if (is_v != was_v) { - evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, - obj, is_v, was_v); - goto done; + evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); + goto done; } if (obj->changed_map) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* it's not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj); if ((obj->cur.color.r != obj->prev.color.r) || (obj->cur.color.g != obj->prev.color.g) || @@ -339,7 +338,7 @@ evas_object_line_render_pre(Evas_Object *obj) ) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } @@ -357,62 +356,51 @@ evas_object_line_render_pre(Evas_Object *obj) (o->cur.y2 != o->prev.y2))) ) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); - goto done; + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); + goto done; } - -done: - evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, obj, - is_v, was_v); + done: + evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); } static void -evas_object_line_render_post(Evas_Object *obj) +evas_object_line_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { - Evas_Object_Line *o; + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); /* this moves the current data to the previous state parts of the object */ /* in whatever way is safest for the object. also if we don't need object */ /* data anymore we can free it if the object deems this is a good idea */ - o = (Evas_Object_Line *)(obj->object_data); /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); o->prev = o->cur; o->changed = EINA_FALSE; } -static unsigned int evas_object_line_id_get(Evas_Object *obj) +static unsigned int evas_object_line_id_get(Evas_Object *eo_obj) { - Evas_Object_Line *o; - - o = (Evas_Object_Line *)(obj->object_data); + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_LINE; } -static unsigned int evas_object_line_visual_id_get(Evas_Object *obj) +static unsigned int evas_object_line_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Line *o; - - o = (Evas_Object_Line *)(obj->object_data); + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_SHAPE; } -static void *evas_object_line_engine_data_get(Evas_Object *obj) +static void *evas_object_line_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Line *o; - - o = (Evas_Object_Line *)(obj->object_data); - if (!o) return NULL; + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); return o->engine_data; } static int -evas_object_line_is_opaque(Evas_Object *obj __UNUSED__) +evas_object_line_is_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object is */ /* currently fully opaque over the entire line it occupies */ @@ -420,7 +408,7 @@ evas_object_line_is_opaque(Evas_Object *obj __UNUSED__) } static int -evas_object_line_was_opaque(Evas_Object *obj __UNUSED__) +evas_object_line_was_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object was */ /* previously fully opaque over the entire line it occupies */ @@ -428,7 +416,7 @@ evas_object_line_was_opaque(Evas_Object *obj __UNUSED__) } static int -evas_object_line_is_inside(Evas_Object *obj __UNUSED__, Evas_Coord x __UNUSED__, Evas_Coord y __UNUSED__) +evas_object_line_is_inside(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED, Evas_Coord x EINA_UNUSED, Evas_Coord y EINA_UNUSED) { /* this returns 1 if the canvas co-ordinates are inside the object based */ /* on object private data. not much use for rects, but for polys, images */ @@ -437,7 +425,7 @@ evas_object_line_is_inside(Evas_Object *obj __UNUSED__, Evas_Coord x __UNUSED__, } static int -evas_object_line_was_inside(Evas_Object *obj __UNUSED__, Evas_Coord x __UNUSED__, Evas_Coord y __UNUSED__) +evas_object_line_was_inside(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED, Evas_Coord x EINA_UNUSED, Evas_Coord y EINA_UNUSED) { /* this returns 1 if the canvas co-ordinates were inside the object based */ /* on object private data. not much use for rects, but for polys, images */ @@ -446,11 +434,10 @@ evas_object_line_was_inside(Evas_Object *obj __UNUSED__, Evas_Coord x __UNUSED__ } static void -evas_object_line_coords_recalc(Evas_Object *obj) +evas_object_line_coords_recalc(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Line *o; + Evas_Object_Line *o = eo_data_get(eo_obj, MY_CLASS); - o = (Evas_Object_Line *)(obj->object_data); o->cur.cache.x1 = obj->cur.geometry.x + o->cur.x1; o->cur.cache.y1 = obj->cur.geometry.y + o->cur.y1; o->cur.cache.x2 = obj->cur.geometry.x + o->cur.x2; @@ -458,3 +445,37 @@ evas_object_line_coords_recalc(Evas_Object *obj) o->cur.cache.object.w = obj->cur.geometry.w; o->cur.cache.object.h = obj->cur.geometry.h; } + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_OBJ_LINE_ID(EVAS_OBJ_LINE_SUB_ID_XY_SET), _line_xy_set), + EO_OP_FUNC(EVAS_OBJ_LINE_ID(EVAS_OBJ_LINE_SUB_ID_XY_GET), _line_xy_get), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_LINE_SUB_ID_XY_SET, "Sets the coordinates of the end points of the given evas line object."), + EO_OP_DESCRIPTION(EVAS_OBJ_LINE_SUB_ID_XY_GET, "Retrieves the coordinates of the end points of the given evas line object."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Line", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_LINE_BASE_ID, op_desc, EVAS_OBJ_LINE_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Line), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_line_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_main.c b/legacy/evas/src/lib/canvas/evas_object_main.c index 990ddc6df2..6ee429a0bf 100644 --- a/legacy/evas/src/lib/canvas/evas_object_main.c +++ b/legacy/evas/src/lib/canvas/evas_object_main.c @@ -1,9 +1,21 @@ #include "evas_common.h" #include "evas_private.h" -EVAS_MEMPOOL(_mp_obj); EVAS_MEMPOOL(_mp_sh); +#include "Eo.h" + +#define MY_CLASS EVAS_OBJ_CLASS + +#define MY_CLASS_NAME "Evas_Object" + +EAPI Eo_Op EVAS_OBJ_BASE_ID = EO_NOOP; + +static void +_show(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void +_hide(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); + static Eina_Inlist * get_layer_objects(Evas_Layer *l) { @@ -12,27 +24,31 @@ get_layer_objects(Evas_Layer *l) } /* evas internal stuff */ -Evas_Object * -evas_object_new(Evas *e __UNUSED__) +static void +_constructor(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) { - Evas_Object *obj; + eo_do_super(eo_obj, eo_constructor()); + eo_do(eo_obj, evas_obj_type_set(MY_CLASS_NAME)); + eo_manual_free_set(eo_obj, EINA_TRUE); - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object", Evas_Object, 32, NULL); - obj = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object); - if (!obj) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, obj, Evas_Object); + Evas_Object_Protected_Data *obj = _pd; + if (!obj) + { + eo_error_set(eo_obj); + return; + } - obj->magic = MAGIC_OBJ; obj->cur.scale = 1.0; obj->prev.scale = 1.0; obj->is_frame = EINA_FALSE; - - return obj; + obj->object = eo_obj; } void -evas_object_change_reset(Evas_Object *obj) +evas_object_change_reset(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + if (!obj) return; obj->changed = EINA_FALSE; obj->changed_move = EINA_FALSE; obj->changed_color = EINA_FALSE; @@ -41,8 +57,9 @@ evas_object_change_reset(Evas_Object *obj) } void -evas_object_cur_prev(Evas_Object *obj) +evas_object_cur_prev(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); if (!obj->prev.valid_map) { if (obj->prev.map != obj->cur.map) @@ -61,15 +78,19 @@ evas_object_cur_prev(Evas_Object *obj) } void -evas_object_free(Evas_Object *obj, int clean_layer) +evas_object_free(Evas_Object *eo_obj, int clean_layer) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + if (!obj) return; + obj->clean_layer = clean_layer; + int was_smart_child = 0; #if 0 // filtering disabled - evas_filter_free(obj); + evas_filter_free(eo_obj); #endif - if (!strcmp(obj->type, "image")) evas_object_image_video_surface_set(obj, NULL); - evas_object_map_set(obj, NULL); + if (!strcmp(obj->type, "image")) evas_object_image_video_surface_set(eo_obj, NULL); + evas_object_map_set(eo_obj, NULL); if (obj->prev.map) evas_map_free(obj->prev.map); if (obj->cache_map) evas_map_free(obj->cache_map); if (obj->map.surface) @@ -79,17 +100,20 @@ evas_object_free(Evas_Object *obj, int clean_layer) obj->map.surface); obj->map.surface = NULL; } - evas_object_grabs_cleanup(obj); - evas_object_intercept_cleanup(obj); + evas_object_grabs_cleanup(eo_obj, obj); + evas_object_intercept_cleanup(eo_obj); if (obj->smart.parent) was_smart_child = 1; - evas_object_smart_cleanup(obj); - obj->func->free(obj); - if (!was_smart_child) evas_object_release(obj, clean_layer); + evas_object_smart_cleanup(eo_obj); + if (obj->func->free) + { + obj->func->free(eo_obj, obj); + } + if (!was_smart_child) evas_object_release(eo_obj, obj, obj->clean_layer); if (obj->clip.clipees) eina_list_free(obj->clip.clipees); - evas_object_clip_changes_clean(obj); - evas_object_event_callback_all_del(obj); - evas_object_event_callback_cleanup(obj); + evas_object_clip_changes_clean(eo_obj); + evas_object_event_callback_all_del(eo_obj); + evas_object_event_callback_cleanup(eo_obj); if (obj->spans) { free(obj->spans); @@ -103,19 +127,18 @@ evas_object_free(Evas_Object *obj, int clean_layer) obj->data.elements = eina_list_remove(obj->data.elements, node); free(node); } - obj->magic = 0; if (obj->size_hints) { EVAS_MEMPOOL_FREE(_mp_sh, obj->size_hints); } - EVAS_MEMPOOL_FREE(_mp_obj, obj); + eo_manual_free(eo_obj); } void -evas_object_change(Evas_Object *obj) +evas_object_change(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { Eina_List *l; - Evas_Object *obj2; + Evas_Object *eo_obj2; Eina_Bool movch = EINA_FALSE; if (obj->layer->evas->nochange) return; @@ -129,24 +152,34 @@ evas_object_change(Evas_Object *obj) if (obj->changed) return; - evas_render_object_recalc(obj); + evas_render_object_recalc(eo_obj); /* set changed flag on all objects this one clips too */ if (!((movch) && (obj->is_static_clip))) { - EINA_LIST_FOREACH(obj->clip.clipees, l, obj2) - evas_object_change(obj2); + EINA_LIST_FOREACH(obj->clip.clipees, l, eo_obj2) + { + Evas_Object_Protected_Data *obj2 = eo_data_get(eo_obj2, MY_CLASS); + evas_object_change(eo_obj2, obj2); + } } - EINA_LIST_FOREACH(obj->proxy.proxies, l, obj2) + EINA_LIST_FOREACH(obj->proxy.proxies, l, eo_obj2) { - evas_object_change(obj2); + Evas_Object_Protected_Data *obj2 = eo_data_get(eo_obj2, MY_CLASS); + evas_object_change(eo_obj2, obj2); + } + if (obj->smart.parent) + { + Evas_Object_Protected_Data *smart_parent = eo_data_get(obj->smart.parent, MY_CLASS); + evas_object_change(obj->smart.parent, smart_parent); } - if (obj->smart.parent) evas_object_change(obj->smart.parent); } void -evas_object_render_pre_visible_change(Eina_Array *rects, Evas_Object *obj, int is_v, int was_v) +evas_object_render_pre_visible_change(Eina_Array *rects, Evas_Object *eo_obj, int is_v, int was_v) { - if (obj->smart.smart) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + + if (obj->is_smart) return; if (is_v == was_v) return; if (is_v) { @@ -167,22 +200,30 @@ evas_object_render_pre_visible_change(Eina_Array *rects, Evas_Object *obj, int i } void -evas_object_render_pre_clipper_change(Eina_Array *rects, Evas_Object *obj) +evas_object_render_pre_clipper_change(Eina_Array *rects, Evas_Object *eo_obj) { - if (obj->smart.smart) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + + Evas_Object_Protected_Data *cur_clipper = NULL; + Evas_Object_Protected_Data *prev_clipper = NULL; + if (obj->is_smart) return; if (obj->cur.clipper == obj->prev.clipper) return; + if (obj->cur.clipper) + cur_clipper = eo_data_get(obj->cur.clipper, MY_CLASS); + if (obj->prev.clipper) + prev_clipper = eo_data_get(obj->prev.clipper, MY_CLASS); if ((obj->cur.clipper) && (obj->prev.clipper)) { /* get difference rects between clippers */ evas_rects_return_difference_rects(rects, - obj->cur.clipper->cur.cache.clip.x, - obj->cur.clipper->cur.cache.clip.y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h, - obj->prev.clipper->prev.cache.clip.x, - obj->prev.clipper->prev.cache.clip.y, - obj->prev.clipper->prev.cache.clip.w, - obj->prev.clipper->prev.cache.clip.h); + cur_clipper->cur.cache.clip.x, + cur_clipper->cur.cache.clip.y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h, + prev_clipper->prev.cache.clip.x, + prev_clipper->prev.cache.clip.y, + prev_clipper->prev.cache.clip.w, + prev_clipper->prev.cache.clip.h); } else if (obj->cur.clipper) { @@ -195,10 +236,10 @@ evas_object_render_pre_clipper_change(Eina_Array *rects, Evas_Object *obj) //// obj->cur.cache.geometry.y, //// obj->cur.cache.geometry.w, //// obj->cur.cache.geometry.h, - obj->cur.clipper->cur.cache.clip.x, - obj->cur.clipper->cur.cache.clip.y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x, + cur_clipper->cur.cache.clip.y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); } else if (obj->prev.clipper) { @@ -211,16 +252,18 @@ evas_object_render_pre_clipper_change(Eina_Array *rects, Evas_Object *obj) //// obj->prev.cache.geometry.y, //// obj->prev.cache.geometry.w, //// obj->prev.cache.geometry.h, - obj->prev.clipper->prev.cache.clip.x, - obj->prev.clipper->prev.cache.clip.y, - obj->prev.clipper->prev.cache.clip.w, - obj->prev.clipper->prev.cache.clip.h); + prev_clipper->prev.cache.clip.x, + prev_clipper->prev.cache.clip.y, + prev_clipper->prev.cache.clip.w, + prev_clipper->prev.cache.clip.h); } } void -evas_object_render_pre_prev_cur_add(Eina_Array *rects, Evas_Object *obj) +evas_object_render_pre_prev_cur_add(Eina_Array *rects, Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { + if (!obj) return; + evas_add_rect(rects, obj->cur.cache.clip.x, obj->cur.cache.clip.y, @@ -254,8 +297,11 @@ evas_object_render_pre_prev_cur_add(Eina_Array *rects, Evas_Object *obj) } void -evas_object_clip_changes_clean(Evas_Object *obj) +evas_object_clip_changes_clean(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + if (!obj) return; + Eina_Rectangle *r; EINA_LIST_FREE(obj->clip.changes, r) @@ -263,16 +309,19 @@ evas_object_clip_changes_clean(Evas_Object *obj) } void -evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *obj, int is_v, int was_v __UNUSED__) +evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *eo_obj, int is_v, int was_v EINA_UNUSED) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + if (!obj) return; + Eina_Rectangle *r; - Evas_Object *clipper; + Evas_Object *eo_clipper; Eina_List *l; unsigned int i; Eina_Array_Iterator it; int x, y, w, h; - if (obj->smart.smart) goto end; + if (obj->is_smart) goto end; /* FIXME: was_v isn't used... why? */ if (!obj->clip.clipees) { @@ -308,9 +357,10 @@ evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *obj, int i /* if the object is actually visible, take any parent clip changes */ if (is_v) { - clipper = obj->cur.clipper; - while (clipper) + eo_clipper = obj->cur.clipper; + while (eo_clipper) { + Evas_Object_Protected_Data *clipper = eo_data_get(eo_clipper, MY_CLASS); EINA_LIST_FOREACH(clipper->clip.changes, l, r) { /* get updates and clip to current clip */ @@ -334,13 +384,13 @@ evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *obj, int i obj->layer->evas->engine.func->output_redraws_rect_add(obj->layer->evas->engine.data.output, x, y, w, h); } - clipper = clipper->cur.clipper; + eo_clipper = clipper->cur.clipper; } } } else { - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); EINA_ARRAY_ITER_NEXT(rects, i, r, it) obj->clip.changes = eina_list_append(obj->clip.changes, r); eina_array_clean(rects); @@ -353,9 +403,9 @@ evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *obj, int i } int -evas_object_was_in_output_rect(Evas_Object *obj, int x, int y, int w, int h) +evas_object_was_in_output_rect(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, int x, int y, int w, int h) { - if (obj->smart.smart && !obj->prev.map && !obj->prev.usemap) return 0; + if (obj->is_smart && !obj->prev.map && !obj->prev.usemap) return 0; /* assumes coords have been recalced */ if ((RECTS_INTERSECT(x, y, w, h, obj->prev.cache.clip.x, @@ -367,124 +417,155 @@ evas_object_was_in_output_rect(Evas_Object *obj, int x, int y, int w, int h) } int -evas_object_was_opaque(Evas_Object *obj) +evas_object_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - if (obj->smart.smart) return 0; + if (obj->is_smart) return 0; if (obj->prev.cache.clip.a == 255) { if (obj->func->was_opaque) - return obj->func->was_opaque(obj); + return obj->func->was_opaque(eo_obj, obj); return 1; } return 0; } int -evas_object_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_is_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y) { - if (obj->smart.smart) return 0; + if (obj->is_smart) return 0; if (obj->func->is_inside) - return obj->func->is_inside(obj, x, y); + return obj->func->is_inside(eo_obj, obj, x, y); return 0; } int -evas_object_was_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_was_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y) { - if (obj->smart.smart) return 0; + if (obj->is_smart) return 0; if (obj->func->was_inside) - return obj->func->was_inside(obj, x, y); + return obj->func->was_inside(eo_obj, obj, x, y); return 0; } /* routines apps will call */ EAPI void -evas_object_ref(Evas_Object *obj) +evas_object_ref(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + + eo_ref(eo_obj); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); obj->ref++; } EAPI void -evas_object_unref(Evas_Object *obj) +evas_object_unref(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + if (obj->ref == 0) return; obj->ref--; - if ((obj->del_ref) && (obj->ref == 0)) evas_object_del(obj); + eo_unref(eo_obj); + if ((obj->del_ref) && (obj->ref == 0)) evas_object_del(eo_obj); + } EAPI int -evas_object_ref_get(const Evas_Object *obj) +evas_object_ref_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); return obj->ref; } EAPI void -evas_object_del(Evas_Object *obj) +evas_object_del(Evas_Object *eo_obj) { - if (!obj) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + if (!eo_obj) return; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - if (obj->delete_me) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); + if (obj->delete_me || obj->eo_del_called) return; if (obj->ref > 0) { obj->del_ref = EINA_TRUE; return; } - evas_object_hide(obj); + obj->eo_del_called = EINA_TRUE; + + eo_parent_set(eo_obj, NULL); +// eo_del(eo_obj); +} + +static void +_destructor(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = _pd; + + evas_object_hide(eo_obj); if (obj->focused) { obj->focused = EINA_FALSE; obj->layer->evas->focused = NULL; _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_FOCUS_OUT, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_FOCUS_OUT, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); } _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_DEL, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_DEL, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); if (obj->mouse_grabbed > 0) obj->layer->evas->pointer.mouse_grabbed -= obj->mouse_grabbed; if ((obj->mouse_in) || (obj->mouse_grabbed > 0)) obj->layer->evas->pointer.object.in = eina_list_remove(obj->layer->evas->pointer.object.in, obj); obj->mouse_grabbed = 0; obj->mouse_in = 0; - if (obj->name) evas_object_name_set(obj, NULL); + if (obj->name) evas_object_name_set(eo_obj, NULL); if (!obj->layer) { - evas_object_free(obj, 1); - return; + eo_manual_free_set(eo_obj, EINA_FALSE); + obj->clean_layer = 1; + goto end; } - evas_object_grabs_cleanup(obj); + evas_object_grabs_cleanup(eo_obj, obj); while (obj->clip.clipees) evas_object_clip_unset(obj->clip.clipees->data); while (obj->proxy.proxies) evas_object_image_source_unset(obj->proxy.proxies->data); - if (obj->cur.clipper) evas_object_clip_unset(obj); - evas_object_map_set(obj, NULL); - if (obj->smart.smart) evas_object_smart_del(obj); + if (obj->cur.clipper) evas_object_clip_unset(eo_obj); + evas_object_map_set(eo_obj, NULL); + if (obj->is_smart) evas_object_smart_del(eo_obj); _evas_object_event_new(); - evas_object_event_callback_call(obj, EVAS_CALLBACK_FREE, NULL, _evas_event_counter); - _evas_post_event_callback_call(obj->layer->evas); - evas_object_smart_cleanup(obj); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_FREE, NULL, _evas_event_counter); + _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas); + evas_object_smart_cleanup(eo_obj); obj->delete_me = 1; - evas_object_change(obj); + evas_object_change(eo_obj, obj); +end: + obj->supported_types = eina_list_free(obj->supported_types); + eo_do_super(eo_obj, eo_destructor()); } + void -evas_object_update_bounding_box(Evas_Object *obj) +evas_object_update_bounding_box(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { Eina_Bool propagate = EINA_FALSE; Eina_Bool computeminmax = EINA_FALSE; @@ -498,7 +579,7 @@ evas_object_update_bounding_box(Evas_Object *obj) to reduce the bounding of the object they are clipping, but for the moment this will do it's jobs */ noclip = !(obj->clip.clipees || obj->is_static_clip); - if (obj->smart.smart) + if (obj->is_smart) { x = obj->cur.bounding_box.x; y = obj->cur.bounding_box.y; @@ -525,56 +606,57 @@ evas_object_update_bounding_box(Evas_Object *obj) * That's why we initialiaze min and max search to geometry of the parent object. */ - if (obj->smart.parent->cur.valid_bounding_box) + Evas_Object_Protected_Data *smart_parent = eo_data_get(obj->smart.parent, MY_CLASS); + if (smart_parent->cur.valid_bounding_box) { /* Update left limit */ - if (noclip && x < obj->smart.parent->cur.bounding_box.x) + if (noclip && x < smart_parent->cur.bounding_box.x) { - obj->smart.parent->cur.bounding_box.w += obj->smart.parent->cur.bounding_box.x - x; - obj->smart.parent->cur.bounding_box.x = x; + smart_parent->cur.bounding_box.w += smart_parent->cur.bounding_box.x - x; + smart_parent->cur.bounding_box.x = x; propagate = EINA_TRUE; } - else if ((px == obj->smart.parent->prev.bounding_box.x && x > obj->smart.parent->cur.bounding_box.x) - || (!noclip && x == obj->smart.parent->cur.bounding_box.x)) + else if ((px == smart_parent->prev.bounding_box.x && x > smart_parent->cur.bounding_box.x) + || (!noclip && x == smart_parent->cur.bounding_box.x)) { computeminmax = EINA_TRUE; } /* Update top limit */ - if (noclip && y < obj->smart.parent->cur.bounding_box.y) + if (noclip && y < smart_parent->cur.bounding_box.y) { - obj->smart.parent->cur.bounding_box.h += obj->smart.parent->cur.bounding_box.x - x; - obj->smart.parent->cur.bounding_box.y = y; + smart_parent->cur.bounding_box.h += smart_parent->cur.bounding_box.x - x; + smart_parent->cur.bounding_box.y = y; propagate = EINA_TRUE; } - else if ((py == obj->smart.parent->prev.bounding_box.y && y > obj->smart.parent->cur.bounding_box.y) - || (!noclip && y == obj->smart.parent->cur.bounding_box.y)) + else if ((py == smart_parent->prev.bounding_box.y && y > smart_parent->cur.bounding_box.y) + || (!noclip && y == smart_parent->cur.bounding_box.y)) { computeminmax = EINA_TRUE; } /* Update right limit */ - if (noclip && x + w > obj->smart.parent->cur.bounding_box.x + obj->smart.parent->cur.bounding_box.w) + if (noclip && x + w > smart_parent->cur.bounding_box.x + smart_parent->cur.bounding_box.w) { - obj->smart.parent->cur.bounding_box.w = x + w - obj->smart.parent->cur.bounding_box.x; + smart_parent->cur.bounding_box.w = x + w - smart_parent->cur.bounding_box.x; propagate = EINA_TRUE; } - else if ((px + pw == obj->smart.parent->prev.bounding_box.x + obj->smart.parent->prev.bounding_box.w && - x + w < obj->smart.parent->cur.bounding_box.x + obj->smart.parent->cur.bounding_box.w) - || (!noclip && x + w == obj->smart.parent->cur.bounding_box.x + obj->smart.parent->cur.bounding_box.w)) + else if ((px + pw == smart_parent->prev.bounding_box.x + smart_parent->prev.bounding_box.w && + x + w < smart_parent->cur.bounding_box.x + smart_parent->cur.bounding_box.w) + || (!noclip && x + w == smart_parent->cur.bounding_box.x + smart_parent->cur.bounding_box.w)) { computeminmax = EINA_TRUE; } /* Update bottom limit */ - if (noclip && y + h > obj->smart.parent->cur.bounding_box.y + obj->smart.parent->cur.bounding_box.h) + if (noclip && y + h > smart_parent->cur.bounding_box.y + smart_parent->cur.bounding_box.h) { - obj->smart.parent->cur.bounding_box.h = y + h - obj->smart.parent->cur.bounding_box.y; + smart_parent->cur.bounding_box.h = y + h - smart_parent->cur.bounding_box.y; propagate = EINA_TRUE; } - else if ((py + ph == obj->smart.parent->prev.bounding_box.y + obj->smart.parent->prev.bounding_box.h && - y + h < obj->smart.parent->cur.bounding_box.y + obj->smart.parent->cur.bounding_box.h) || - (!noclip && y + h == obj->smart.parent->cur.bounding_box.y + obj->smart.parent->cur.bounding_box.h)) + else if ((py + ph == smart_parent->prev.bounding_box.y + smart_parent->prev.bounding_box.h && + y + h < smart_parent->cur.bounding_box.y + smart_parent->cur.bounding_box.h) || + (!noclip && y + h == smart_parent->cur.bounding_box.y + smart_parent->cur.bounding_box.h)) { computeminmax = EINA_TRUE; } @@ -588,29 +670,40 @@ evas_object_update_bounding_box(Evas_Object *obj) { if (noclip) { - obj->smart.parent->cur.bounding_box.x = x; - obj->smart.parent->cur.bounding_box.y = y; - obj->smart.parent->cur.bounding_box.w = w; - obj->smart.parent->cur.bounding_box.h = h; - obj->smart.parent->cur.valid_bounding_box = EINA_TRUE; + smart_parent->cur.bounding_box.x = x; + smart_parent->cur.bounding_box.y = y; + smart_parent->cur.bounding_box.w = w; + smart_parent->cur.bounding_box.h = h; + smart_parent->cur.valid_bounding_box = EINA_TRUE; propagate = EINA_TRUE; } } if (propagate) - evas_object_update_bounding_box(obj->smart.parent); + evas_object_update_bounding_box(obj->smart.parent, smart_parent); } EAPI void -evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_move(Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y) { - Evas *evas; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_position_set(x, y)); +} + +static void +_position_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + + Evas_Public_Data *evas; int is, was = 0, pass = 0, freeze = 0; int nx = 0, ny = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); if (obj->delete_me) return; nx = x; @@ -618,16 +711,16 @@ evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) evas = obj->layer->evas; - if ((!obj->is_frame) && (obj != evas->framespace.clip)) + if ((!obj->is_frame) && (eo_obj != evas->framespace.clip)) { - if ((!obj->smart.parent) && (obj->smart.smart)) + if ((!obj->smart.parent) && (obj->is_smart)) { nx += evas->framespace.x; ny += evas->framespace.y; } } - if (evas_object_intercept_call_move(obj, nx, ny)) return; + if (evas_object_intercept_call_move(eo_obj, obj, nx, ny)) return; if (obj->doing.in_move > 0) { @@ -637,45 +730,44 @@ evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) if ((obj->cur.geometry.x == nx) && (obj->cur.geometry.y == ny)) return; - if (obj->layer->evas->events_frozen <= 0) + if (!(obj->layer->evas->is_frozen)) { - pass = evas_event_passes_through(obj); - freeze = evas_event_freezes_through(obj); + pass = evas_event_passes_through(eo_obj, obj); + freeze = evas_event_freezes_through(eo_obj, obj); if ((!pass) && (!freeze)) - was = evas_object_is_in_output_rect(obj, + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); } obj->doing.in_move++; - if (obj->smart.smart) + if (obj->is_smart) { - if (obj->smart.smart->smart_class->move) - obj->smart.smart->smart_class->move(obj, nx, ny); + eo_do(eo_obj, evas_obj_smart_move(nx, ny)); } obj->cur.geometry.x = nx; obj->cur.geometry.y = ny; - evas_object_update_bounding_box(obj); + evas_object_update_bounding_box(eo_obj, obj); //// obj->cur.cache.geometry.validity = 0; obj->changed_move = EINA_TRUE; - evas_object_change(obj); - evas_object_clip_dirty(obj); + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); obj->doing.in_move--; - if (obj->layer->evas->events_frozen <= 0) + if (!(obj->layer->evas->is_frozen)) { - evas_object_recalc_clippees(obj); + evas_object_recalc_clippees(eo_obj, obj); if (!pass) { - if (!obj->smart.smart) + if (!obj->is_smart) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is ^ was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -683,21 +775,32 @@ evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) } } } - evas_object_inform_call_move(obj); + evas_object_inform_call_move(eo_obj, obj); } EAPI void -evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h) +evas_object_resize(Evas_Object *eo_obj, Evas_Coord w, Evas_Coord h) { - int is, was = 0, pass = 0, freeze =0; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_set(w, h)); +} + +static void +_size_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + + int is, was = 0, pass = 0, freeze =0; + if (obj->delete_me) return; if (w < 0) w = 0; if (h < 0) h = 0; - if (evas_object_intercept_call_resize(obj, w, h)) return; + if (evas_object_intercept_call_resize(eo_obj, w, h)) return; if (obj->doing.in_resize > 0) { @@ -707,48 +810,47 @@ evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h) if ((obj->cur.geometry.w == w) && (obj->cur.geometry.h == h)) return; - if (obj->layer->evas->events_frozen <= 0) + if (!(obj->layer->evas->is_frozen)) { - pass = evas_event_passes_through(obj); - freeze = evas_event_freezes_through(obj); + pass = evas_event_passes_through(eo_obj, obj); + freeze = evas_event_freezes_through(eo_obj, obj); if ((!pass) && (!freeze)) - was = evas_object_is_in_output_rect(obj, + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); } obj->doing.in_resize++; - if (obj->smart.smart) + if (obj->is_smart) { - if (obj->smart.smart->smart_class->resize) - obj->smart.smart->smart_class->resize(obj, w, h); + eo_do(eo_obj, evas_obj_smart_resize(w, h)); } obj->cur.geometry.w = w; obj->cur.geometry.h = h; - evas_object_update_bounding_box(obj); + evas_object_update_bounding_box(eo_obj, obj); //// obj->cur.cache.geometry.validity = 0; - evas_object_change(obj); - evas_object_clip_dirty(obj); + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); obj->doing.in_resize--; /* NB: evas_object_recalc_clippees was here previously ( < 08/07/2009) */ - if (obj->layer->evas->events_frozen <= 0) + if (!(obj->layer->evas->is_frozen)) { /* NB: If this creates glitches on screen then move to above position */ - evas_object_recalc_clippees(obj); + evas_object_recalc_clippees(eo_obj, obj); - // if (obj->func->coords_recalc) obj->func->coords_recalc(obj); + // if (obj->func->coords_recalc) obj->func->coords_recalc(eo_obj); if (!pass) { - if (!obj->smart.smart) + if (!obj->is_smart) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is ^ was) && (obj->cur.visible)) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -756,22 +858,33 @@ evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h) } } } - evas_object_inform_call_resize(obj); + evas_object_inform_call_resize(eo_obj); } EAPI void -evas_object_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) +evas_object_geometry_get(const Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - Evas *evas; - int nx = 0, ny = 0; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_position_get(x, y), evas_obj_size_get(w, h)); +} + +static void +_position_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Public_Data *evas; + int nx = 0, ny = 0; + + const Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord *x = va_arg(*list, Evas_Coord *); + Evas_Coord *y = va_arg(*list, Evas_Coord *); + if (obj->delete_me) { - if (x) *x = 0; if (y) *y = 0; if (w) *w = 0; if (h) *h = 0; + if (x) *x = 0; if (y) *y = 0; return; } @@ -780,9 +893,9 @@ evas_object_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, E evas = obj->layer->evas; - if ((!obj->is_frame) && (obj != evas->framespace.clip)) + if ((!obj->is_frame) && (eo_obj != evas->framespace.clip)) { - if ((!obj->smart.parent) && (obj->smart.smart)) + if ((!obj->smart.parent) && (obj->is_smart)) { if (nx > 0) nx -= evas->framespace.x; if (ny > 0) ny -= evas->framespace.y; @@ -791,12 +904,28 @@ evas_object_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, E if (x) *x = nx; if (y) *y = ny; +} + +static void +_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + + if (obj->delete_me) + { + if (w) *w = 0; if (h) *h = 0; + return; + } + if (w) *w = obj->cur.geometry.w; if (h) *h = obj->cur.geometry.h; } static void -_evas_object_size_hint_alloc(Evas_Object *obj) +_evas_object_size_hint_alloc(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { if (obj->size_hints) return; @@ -812,38 +941,51 @@ _evas_object_size_hint_alloc(Evas_Object *obj) } EAPI Evas_Display_Mode -evas_object_size_hint_display_mode_get(const Evas_Object *obj) +evas_object_size_hint_display_mode_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EVAS_DISPLAY_MODE_NONE; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); if ((!obj->size_hints) || obj->delete_me) return EVAS_DISPLAY_MODE_NONE; return obj->size_hints->dispmode; } EAPI void -evas_object_size_hint_display_mode_set(Evas_Object *obj, Evas_Display_Mode dispmode) +evas_object_size_hint_display_mode_set(Evas_Object *eo_obj, Evas_Display_Mode dispmode) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, MY_CLASS); if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if (obj->size_hints->dispmode == dispmode) return; obj->size_hints->dispmode = dispmode; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_min_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) +evas_object_size_hint_min_get(const Evas_Object *eo_obj, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_min_get(w, h)); +} + +static void +_size_hint_min_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + if ((!obj->size_hints) || obj->delete_me) { if (w) *w = 0; if (h) *h = 0; @@ -854,28 +996,50 @@ evas_object_size_hint_min_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord } EAPI void -evas_object_size_hint_min_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h) +evas_object_size_hint_min_set(Evas_Object *eo_obj, Evas_Coord w, Evas_Coord h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_min_set(w, h)); +} + +static void +_size_hint_min_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->min.w == w) && (obj->size_hints->min.h == h)) return; obj->size_hints->min.w = w; obj->size_hints->min.h = h; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_max_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) +evas_object_size_hint_max_get(const Evas_Object *eo_obj, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (w) *w = -1; if (h) *h = -1; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_max_get(w, h)); +} + +static void +_size_hint_max_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + if ((!obj->size_hints) || obj->delete_me) { if (w) *w = -1; if (h) *h = -1; @@ -886,28 +1050,50 @@ evas_object_size_hint_max_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord } EAPI void -evas_object_size_hint_max_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h) +evas_object_size_hint_max_set(Evas_Object *eo_obj, Evas_Coord w, Evas_Coord h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_max_set(w, h)); +} + +static void +_size_hint_max_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->max.w == w) && (obj->size_hints->max.h == h)) return; obj->size_hints->max.w = w; obj->size_hints->max.h = h; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_request_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) +evas_object_size_hint_request_get(const Evas_Object *eo_obj, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_request_get(w, h)); +} + +static void +_size_hint_request_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + if ((!obj->size_hints) || obj->delete_me) { if (w) *w = 0; if (h) *h = 0; @@ -918,29 +1104,52 @@ evas_object_size_hint_request_get(const Evas_Object *obj, Evas_Coord *w, Evas_Co } EAPI void -evas_object_size_hint_request_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h) +evas_object_size_hint_request_set(Evas_Object *eo_obj, Evas_Coord w, Evas_Coord h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_request_set(w, h)); +} + +static void +_size_hint_request_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->request.w == w) && (obj->size_hints->request.h == h)) return; obj->size_hints->request.w = w; obj->size_hints->request.h = h; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_aspect_get(const Evas_Object *obj, Evas_Aspect_Control *aspect, Evas_Coord *w, Evas_Coord *h) +evas_object_size_hint_aspect_get(const Evas_Object *eo_obj, Evas_Aspect_Control *aspect, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (aspect) *aspect = EVAS_ASPECT_CONTROL_NONE; if (w) *w = 0; if (h) *h = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_aspect_get(aspect, w, h)); +} + +static void +_size_hint_aspect_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const const Evas_Object_Protected_Data *obj = _pd; + + Evas_Aspect_Control *aspect = va_arg(*list, Evas_Aspect_Control*); + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + if ((!obj->size_hints) || obj->delete_me) { if (aspect) *aspect = EVAS_ASPECT_CONTROL_NONE; @@ -953,29 +1162,52 @@ evas_object_size_hint_aspect_get(const Evas_Object *obj, Evas_Aspect_Control *as } EAPI void -evas_object_size_hint_aspect_set(Evas_Object *obj, Evas_Aspect_Control aspect, Evas_Coord w, Evas_Coord h) +evas_object_size_hint_aspect_set(Evas_Object *eo_obj, Evas_Aspect_Control aspect, Evas_Coord w, Evas_Coord h) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_aspect_set(aspect, w, h)); +} + +static void +_size_hint_aspect_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Aspect_Control aspect = va_arg(*list, Evas_Aspect_Control); + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->aspect.mode == aspect) && (obj->size_hints->aspect.size.w == w) && (obj->size_hints->aspect.size.h == h)) return; obj->size_hints->aspect.mode = aspect; obj->size_hints->aspect.size.w = w; obj->size_hints->aspect.size.h = h; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_align_get(const Evas_Object *obj, double *x, double *y) +evas_object_size_hint_align_get(const Evas_Object *eo_obj, double *x, double *y) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (x) *x = 0.5; if (y) *y = 0.5; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_align_get(x, y)); +} + +static void +_size_hint_align_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + double *x = va_arg(*list, double *); + double *y = va_arg(*list, double *); + if ((!obj->size_hints) || obj->delete_me) { if (x) *x = 0.5; if (y) *y = 0.5; @@ -986,28 +1218,50 @@ evas_object_size_hint_align_get(const Evas_Object *obj, double *x, double *y) } EAPI void -evas_object_size_hint_align_set(Evas_Object *obj, double x, double y) +evas_object_size_hint_align_set(Evas_Object *eo_obj, double x, double y) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_align_set(x, y)); +} + +static void +_size_hint_align_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + double x = va_arg(*list, double); + double y = va_arg(*list, double); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->align.x == x) && (obj->size_hints->align.y == y)) return; obj->size_hints->align.x = x; obj->size_hints->align.y = y; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_weight_get(const Evas_Object *obj, double *x, double *y) +evas_object_size_hint_weight_get(const Evas_Object *eo_obj, double *x, double *y) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (x) *x = 0.0; if (y) *y = 0.0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_weight_get(x, y)); +} + +static void +_size_hint_weight_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + double *x = va_arg(*list, double *); + double *y = va_arg(*list, double *); + if ((!obj->size_hints) || obj->delete_me) { if (x) *x = 0.0; if (y) *y = 0.0; @@ -1018,29 +1272,53 @@ evas_object_size_hint_weight_get(const Evas_Object *obj, double *x, double *y) } EAPI void -evas_object_size_hint_weight_set(Evas_Object *obj, double x, double y) +evas_object_size_hint_weight_set(Evas_Object *eo_obj, double x, double y) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_weight_set(x, y)); +} + +static void +_size_hint_weight_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + double x = va_arg(*list, double); + double y = va_arg(*list, double); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->weight.x == x) && (obj->size_hints->weight.y == y)) return; obj->size_hints->weight.x = x; obj->size_hints->weight.y = y; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_size_hint_padding_get(const Evas_Object *obj, Evas_Coord *l, Evas_Coord *r, Evas_Coord *t, Evas_Coord *b) +evas_object_size_hint_padding_get(const Evas_Object *eo_obj, Evas_Coord *l, Evas_Coord *r, Evas_Coord *t, Evas_Coord *b) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (l) *l = 0; if (r) *r = 0; if (t) *t = 0; if (b) *b = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_size_hint_padding_get(l, r, t, b)); +} + +static void +_size_hint_padding_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord *l = va_arg(*list, Evas_Coord *); + Evas_Coord *r = va_arg(*list, Evas_Coord *); + Evas_Coord *t = va_arg(*list, Evas_Coord *); + Evas_Coord *b = va_arg(*list, Evas_Coord *); + if ((!obj->size_hints) || obj->delete_me) { if (l) *l = 0; if (r) *r = 0; @@ -1054,56 +1332,90 @@ evas_object_size_hint_padding_get(const Evas_Object *obj, Evas_Coord *l, Evas_Co } EAPI void -evas_object_size_hint_padding_set(Evas_Object *obj, Evas_Coord l, Evas_Coord r, Evas_Coord t, Evas_Coord b) +evas_object_size_hint_padding_set(Evas_Object *eo_obj, Evas_Coord l, Evas_Coord r, Evas_Coord t, Evas_Coord b) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_size_hint_padding_set(l, r, t, b)); +} + +static void +_size_hint_padding_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Coord l = va_arg(*list, Evas_Coord); + Evas_Coord r = va_arg(*list, Evas_Coord); + Evas_Coord t = va_arg(*list, Evas_Coord); + Evas_Coord b = va_arg(*list, Evas_Coord); + if (obj->delete_me) return; - _evas_object_size_hint_alloc(obj); + _evas_object_size_hint_alloc(eo_obj, obj); if ((obj->size_hints->padding.l == l) && (obj->size_hints->padding.r == r) && (obj->size_hints->padding.t == t) && (obj->size_hints->padding.b == b)) return; obj->size_hints->padding.l = l; obj->size_hints->padding.r = r; obj->size_hints->padding.t = t; obj->size_hints->padding.b = b; - evas_object_inform_call_changed_size_hints(obj); + evas_object_inform_call_changed_size_hints(eo_obj); } EAPI void -evas_object_show(Evas_Object *obj) +evas_object_show(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_visibility_set(EINA_TRUE)); +} + +EAPI void +evas_object_hide(Evas_Object *eo_obj) +{ + if (!eo_obj) return; + eo_do(eo_obj, evas_obj_visibility_set(EINA_FALSE)); +} + +static void +_visible_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + Eina_Bool visible = va_arg(*list, int); + if (visible) _show(eo_obj, obj); + else _hide(eo_obj, obj); +} + +static void +_show (Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) +{ if (obj->delete_me) return; - if (evas_object_intercept_call_show(obj)) return; - if (obj->smart.smart) + if (evas_object_intercept_call_show(eo_obj)) return; + if (obj->is_smart) { - if (obj->smart.smart->smart_class->show) - obj->smart.smart->smart_class->show(obj); + eo_do(eo_obj, evas_obj_smart_show()); } if (obj->cur.visible) { return; } obj->cur.visible = 1; - evas_object_change(obj); - evas_object_clip_dirty(obj); - if (obj->layer->evas->events_frozen <= 0) + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + if (!(obj->layer->evas->is_frozen)) { - evas_object_clip_across_clippees_check(obj); - evas_object_recalc_clippees(obj); - if ((!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj))) + evas_object_clip_across_clippees_check(eo_obj, obj); + evas_object_recalc_clippees(eo_obj, obj); + if ((!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj))) { - if (!obj->smart.smart) + if (!obj->is_smart) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1)) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -1111,45 +1423,44 @@ evas_object_show(Evas_Object *obj) } } } - evas_object_inform_call_show(obj); + evas_object_inform_call_show(eo_obj); } -EAPI void -evas_object_hide(Evas_Object *obj) +static void +_hide(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); if (obj->delete_me) return; - if (evas_object_intercept_call_hide(obj)) return; - if (obj->smart.smart) + if (evas_object_intercept_call_hide(eo_obj)) return; + if (obj->is_smart) { - if (obj->smart.smart->smart_class->hide) - obj->smart.smart->smart_class->hide(obj); + eo_do(eo_obj, evas_obj_smart_hide()); } if (!obj->cur.visible) { return; } obj->cur.visible = 0; - evas_object_change(obj); - evas_object_clip_dirty(obj); - if (obj->layer->evas->events_frozen <= 0) + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + if (!(obj->layer->evas->is_frozen)) { - evas_object_clip_across_clippees_check(obj); - evas_object_recalc_clippees(obj); - if ((!evas_event_passes_through(obj)) && - (!evas_event_freezes_through(obj))) + evas_object_clip_across_clippees_check(eo_obj, obj); + evas_object_recalc_clippees(eo_obj, obj); + if ((!evas_event_passes_through(eo_obj, obj)) && + (!evas_event_freezes_through(eo_obj, obj))) { - if ((!obj->smart.smart) || + if ((!obj->is_smart) || ((obj->cur.map) && (obj->cur.map->count == 4) && (obj->cur.usemap))) { if (!obj->mouse_grabbed) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1)) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -1165,7 +1476,7 @@ evas_object_hide(Evas_Object *obj) if ((obj->mouse_in) || (obj->mouse_grabbed > 0)) obj->layer->evas->pointer.object.in = eina_list_remove(obj->layer->evas->pointer.object.in, obj); obj->mouse_grabbed = 0; - if (obj->layer->evas->events_frozen > 0) + if (obj->layer->evas->is_frozen) { obj->mouse_in = 0; return; @@ -1187,8 +1498,8 @@ evas_object_hide(Evas_Object *obj) ev.locks = &(obj->layer->evas->locks); ev.timestamp = obj->layer->evas->last_timestamp; ev.event_flags = EVAS_EVENT_FLAG_NONE; - evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev); - _evas_post_event_callback_call(obj->layer->evas); + evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, &ev); + _evas_post_event_callback_call(obj->layer->evas, obj->layer->evas); } */ } @@ -1205,25 +1516,53 @@ evas_object_hide(Evas_Object *obj) obj->mouse_in = 0; */ } - evas_object_inform_call_hide(obj); + evas_object_inform_call_hide(eo_obj); } EAPI Eina_Bool -evas_object_visible_get(const Evas_Object *obj) +evas_object_visible_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - if (obj->delete_me) return 0; - return obj->cur.visible; + Eina_Bool visible = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_visibility_get(&visible)); + return visible; +} + +static void +_visible_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool* visible = va_arg(*list, Eina_Bool *); + const Evas_Object_Protected_Data *obj = _pd; + if (obj->delete_me) + { + if (visible) *visible = EINA_FALSE; + return; + } + + if (visible) *visible = obj->cur.visible; } EAPI void -evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a) +evas_object_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_color_set(r, g, b, a)); +} + +static void +_color_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + if (obj->delete_me) return; if (r > 255) r = 255; if (r < 0) r = 0; if (g > 255) g = 255; if (g < 0) g = 0; @@ -1245,11 +1584,10 @@ evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a) ERR("Evas only handles pre multiplied colors!"); } - if (evas_object_intercept_call_color_set(obj, r, g, b, a)) return; - if (obj->smart.smart) + if (evas_object_intercept_call_color_set(eo_obj, r, g, b, a)) return; + if (obj->is_smart) { - if (obj->smart.smart->smart_class->color_set) - obj->smart.smart->smart_class->color_set(obj, r, g, b, a); + eo_do(eo_obj, evas_obj_smart_color_set(r, g, b, a)); } if ((obj->cur.color.r == r) && (obj->cur.color.g == g) && @@ -1258,21 +1596,32 @@ evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a) obj->cur.color.r = r; obj->cur.color.g = g; obj->cur.color.b = b; - evas_object_clip_dirty(obj); - + evas_object_clip_dirty(eo_obj, obj); if ((obj->cur.color.a == 0) && (a == 0) && (obj->cur.render_op == EVAS_RENDER_BLEND)) return; obj->cur.color.a = a; obj->changed_color = EINA_TRUE; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) +evas_object_color_get(const Evas_Object *eo_obj, int *r, int *g, int *b, int *a) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (r) *r = 0; if (g) *g = 0; if (b) *b = 0; if (a) *a = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_color_get(r, g, b, a)); +} + +static void +_color_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + int* r = va_arg(*list, int *); + int* g = va_arg(*list, int *); + int* b = va_arg(*list, int *); + int* a = va_arg(*list, int *); if (obj->delete_me) { if (r) *r = 0; if (g) *g = 0; if (b) *b = 0; if (a) *a = 0; @@ -1285,191 +1634,342 @@ evas_object_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) } EAPI void -evas_object_anti_alias_set(Evas_Object *obj, Eina_Bool anti_alias) +evas_object_anti_alias_set(Evas_Object *eo_obj, Eina_Bool anti_alias) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_anti_alias_set(anti_alias)); +} + +static void +_anti_alias_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + Eina_Bool anti_alias = va_arg(*list, int); + if (obj->delete_me) return; anti_alias = !!anti_alias; if (obj->cur.anti_alias == anti_alias)return; obj->cur.anti_alias = anti_alias; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI Eina_Bool -evas_object_anti_alias_get(const Evas_Object *obj) +evas_object_anti_alias_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - if (obj->delete_me) return 0; - return obj->cur.anti_alias; + Eina_Bool anti_alias = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_anti_alias_get(&anti_alias)); + return anti_alias; +} + +static void +_anti_alias_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool* anti_alias = va_arg(*list, Eina_Bool *); + + const Evas_Object_Protected_Data *obj = _pd; + if (obj->delete_me) + { + if (anti_alias) *anti_alias = EINA_FALSE; + return; + } + + if (anti_alias) *anti_alias = obj->cur.anti_alias; } EAPI void -evas_object_scale_set(Evas_Object *obj, double scale) +evas_object_scale_set(Evas_Object *eo_obj, double scale) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_scale_set(scale)); +} + +static void +_scale_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + double scale = va_arg(*list, double); if (obj->delete_me) return; if (obj->cur.scale == scale) return; obj->cur.scale = scale; - evas_object_change(obj); - if (obj->func->scale_update) obj->func->scale_update(obj); + evas_object_change(eo_obj, obj); + if (obj->func->scale_update) obj->func->scale_update(eo_obj); } EAPI double -evas_object_scale_get(const Evas_Object *obj) +evas_object_scale_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - if (obj->delete_me) return 1.0; - return obj->cur.scale; + double scale = 1.0; + eo_do((Eo *)eo_obj, evas_obj_scale_get(&scale)); + return scale; +} + +static void +_scale_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + + double* scale = va_arg(*list, double*); + if (obj->delete_me) + { + if (scale) *scale = 1.0; + return; + } + if (scale) *scale = obj->cur.scale; } EAPI void -evas_object_render_op_set(Evas_Object *obj, Evas_Render_Op render_op) +evas_object_render_op_set(Evas_Object *eo_obj, Evas_Render_Op render_op) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_render_op_set(render_op)); +} + +static void +_render_op_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + + Evas_Render_Op render_op = va_arg(*list, Evas_Render_Op); if (obj->delete_me) return; if (obj->cur.render_op == render_op) return; obj->cur.render_op = render_op; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } EAPI Evas_Render_Op -evas_object_render_op_get(const Evas_Object *obj) +evas_object_render_op_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - if (obj->delete_me) return EVAS_RENDER_BLEND; - return obj->cur.render_op; + Evas_Render_Op render_op = EVAS_RENDER_BLEND; + eo_do((Eo *)eo_obj, evas_obj_render_op_get(&render_op)); + return render_op; +} + +static void +_render_op_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Evas_Render_Op* render_op = va_arg(*list, Evas_Render_Op *); + + if (obj->delete_me) + { + if (render_op) *render_op = EVAS_RENDER_BLEND; + return; + } + if (render_op) *render_op = obj->cur.render_op; } EAPI Evas * -evas_object_evas_get(const Evas_Object *obj) +evas_object_evas_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - if (obj->delete_me) return NULL; - return obj->layer->evas; + Evas *eo_evas = NULL; + eo_do((Eo *)eo_obj, evas_common_evas_get(&eo_evas)); + return eo_evas; +} + +static void +_evas_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Evas **evas = va_arg(*list, Evas **); + + if (obj->delete_me) + { + *evas = NULL; + return; + } + *evas = obj->layer->evas->evas; } EAPI Evas_Object * -evas_object_top_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) +evas_object_top_at_xy_get(const Evas *eo_e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) { - Evas_Layer *lay; - int xx, yy; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Evas_Object *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_object_top_at_xy_get(x, y, include_pass_events_objects, include_hidden_objects, &ret)); + return ret; +} + +void +_canvas_object_top_at_xy_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Eina_Bool include_pass_events_objects = va_arg(*list, int); + Eina_Bool include_hidden_objects = va_arg(*list, int); + Evas_Object **ret = va_arg(*list, Evas_Object **); + + Evas_Layer *lay; + int xx, yy; + const Evas_Public_Data *e = _pd; + xx = x; yy = y; -//// xx = evas_coord_world_x_to_screen(e, x); -//// yy = evas_coord_world_y_to_screen(e, y); +//// xx = evas_coord_world_x_to_screen(eo_e, x); +//// yy = evas_coord_world_y_to_screen(eo_e, y); EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay) { - Evas_Object *obj; + Evas_Object *eo_obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_REVERSE_FOREACH(get_layer_objects(lay), obj) { + eo_obj = obj->object; if (obj->delete_me) continue; if ((!include_pass_events_objects) && - (evas_event_passes_through(obj))) continue; + (evas_event_passes_through(eo_obj, obj))) continue; if ((!include_hidden_objects) && (!obj->cur.visible)) continue; - evas_object_clip_recalc(obj); - if ((evas_object_is_in_output_rect(obj, xx, yy, 1, 1)) && + evas_object_clip_recalc(eo_obj, obj); + if ((evas_object_is_in_output_rect(eo_obj, obj, xx, yy, 1, 1)) && (!obj->clip.clipees)) - return obj; + { + *ret = eo_obj; + return; + } } } + *ret = NULL; +} + +EAPI Evas_Object * +evas_object_top_at_pointer_get(const Evas *eo_e) +{ + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); + Evas_Object *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_object_top_at_xy_get(e->pointer.x, e->pointer.y, EINA_TRUE, + EINA_TRUE, &ret)); + return ret; +} + +EAPI Evas_Object * +evas_object_top_in_rectangle_get(const Evas *eo_e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) +{ + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; + MAGIC_CHECK_END(); + Evas_Object *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_object_top_in_rectangle_get(x, y, w, h, include_pass_events_objects, include_hidden_objects, &ret)); + return ret; } -EAPI Evas_Object * -evas_object_top_at_pointer_get(const Evas *e) +void +_canvas_object_top_in_rectangle_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) { - return evas_object_top_at_xy_get(e, e->pointer.x, e->pointer.y, EINA_TRUE, - EINA_TRUE); -} + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + Eina_Bool include_pass_events_objects = va_arg(*list, int); + Eina_Bool include_hidden_objects = va_arg(*list, int); + Evas_Object **ret = va_arg(*list, Evas_Object **); -EAPI Evas_Object * -evas_object_top_in_rectangle_get(const Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) -{ + const Evas_Public_Data *e = _pd; Evas_Layer *lay; int xx, yy, ww, hh; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return NULL; - MAGIC_CHECK_END(); xx = x; yy = y; ww = w; hh = h; -//// xx = evas_coord_world_x_to_screen(e, x); -//// yy = evas_coord_world_y_to_screen(e, y); -//// ww = evas_coord_world_x_to_screen(e, w); -//// hh = evas_coord_world_y_to_screen(e, h); +//// xx = evas_coord_world_x_to_screen(eo_e, x); +//// yy = evas_coord_world_y_to_screen(eo_e, y); +//// ww = evas_coord_world_x_to_screen(eo_e, w); +//// hh = evas_coord_world_y_to_screen(eo_e, h); if (ww < 1) ww = 1; if (hh < 1) hh = 1; EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay) { - Evas_Object *obj; + Evas_Object *eo_obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_REVERSE_FOREACH(get_layer_objects(lay), obj) { + eo_obj = obj->object; if (obj->delete_me) continue; if ((!include_pass_events_objects) && - (evas_event_passes_through(obj))) continue; + (evas_event_passes_through(eo_obj, obj))) continue; if ((!include_hidden_objects) && (!obj->cur.visible)) continue; - evas_object_clip_recalc(obj); - if ((evas_object_is_in_output_rect(obj, xx, yy, ww, hh)) && + evas_object_clip_recalc(eo_obj, obj); + if ((evas_object_is_in_output_rect(eo_obj, obj, xx, yy, ww, hh)) && (!obj->clip.clipees)) - return obj; + { + *ret = eo_obj; + return; + } } } - return NULL; + *ret = NULL; } EAPI Eina_List * -evas_objects_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) +evas_objects_at_xy_get(const Evas *eo_e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return NULL; + MAGIC_CHECK_END(); + Eina_List *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_objects_at_xy_get(x, y, include_pass_events_objects, include_hidden_objects, &ret)); + return ret; +} + +void +_canvas_objects_at_xy_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Eina_Bool include_pass_events_objects = va_arg(*list, int); + Eina_Bool include_hidden_objects = va_arg(*list, int); + Eina_List **ret = va_arg(*list, Eina_List **); + Eina_List *in = NULL; Evas_Layer *lay; int xx, yy; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return NULL; - MAGIC_CHECK_END(); + const Evas_Public_Data *e = _pd; xx = x; yy = y; -//// xx = evas_coord_world_x_to_screen(e, x); -//// yy = evas_coord_world_y_to_screen(e, y); +//// xx = evas_coord_world_x_to_screen(eo_e, x); +//// yy = evas_coord_world_y_to_screen(eo_e, y); EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay) { - Evas_Object *obj; + Evas_Object *eo_obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_REVERSE_FOREACH(get_layer_objects(lay), obj) { + eo_obj = obj->object; + // FIXME - Daniel: we don't know yet how to handle the next line if (obj->delete_me) continue; if ((!include_pass_events_objects) && - (evas_event_passes_through(obj))) continue; + (evas_event_passes_through(eo_obj, obj))) continue; if ((!include_hidden_objects) && (!obj->cur.visible)) continue; - evas_object_clip_recalc(obj); - if ((evas_object_is_in_output_rect(obj, xx, yy, 1, 1)) && + evas_object_clip_recalc(eo_obj, obj); + if ((evas_object_is_in_output_rect(eo_obj, obj, xx, yy, 1, 1)) && (!obj->clip.clipees)) in = eina_list_prepend(in, obj); } } - return in; + *ret = in; } /** @@ -1485,104 +1985,496 @@ evas_objects_at_xy_get(const Evas *e, Evas_Coord x, Evas_Coord y, Eina_Bool incl * */ EAPI Eina_List * -evas_objects_in_rectangle_get(const Evas *e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) +evas_objects_in_rectangle_get(const Evas *eo_e, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects) { + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return NULL; + MAGIC_CHECK_END(); + Eina_List *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_objects_in_rectangle_get(x, y, w, h, include_pass_events_objects, include_hidden_objects, &ret)); + return ret; +} + +void +_canvas_objects_in_rectangle_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + Eina_Bool include_pass_events_objects = va_arg(*list, int); + Eina_Bool include_hidden_objects = va_arg(*list, int); + Eina_List **ret = va_arg(*list, Eina_List **); + Eina_List *in = NULL; Evas_Layer *lay; int xx, yy, ww, hh; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return NULL; - MAGIC_CHECK_END(); + const Evas_Public_Data *e = _pd; xx = x; yy = y; ww = w; hh = h; -//// xx = evas_coord_world_x_to_screen(e, x); -//// yy = evas_coord_world_y_to_screen(e, y); -//// ww = evas_coord_world_x_to_screen(e, w); -//// hh = evas_coord_world_y_to_screen(e, h); +//// xx = evas_coord_world_x_to_screen(eo_e, x); +//// yy = evas_coord_world_y_to_screen(eo_e, y); +//// ww = evas_coord_world_x_to_screen(eo_e, w); +//// hh = evas_coord_world_y_to_screen(eo_e, h); if (ww < 1) ww = 1; if (hh < 1) hh = 1; EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay) { - Evas_Object *obj; + Evas_Object *eo_obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_REVERSE_FOREACH(get_layer_objects(lay), obj) { + eo_obj = obj->object; + // FIXME - Daniel: we don't know yet how to handle the next line if (obj->delete_me) continue; if ((!include_pass_events_objects) && - (evas_event_passes_through(obj))) continue; + (evas_event_passes_through(eo_obj, obj))) continue; if ((!include_hidden_objects) && (!obj->cur.visible)) continue; - evas_object_clip_recalc(obj); - if ((evas_object_is_in_output_rect(obj, xx, yy, ww, hh)) && + evas_object_clip_recalc(eo_obj, obj); + if ((evas_object_is_in_output_rect(eo_obj, obj, xx, yy, ww, hh)) && (!obj->clip.clipees)) in = eina_list_prepend(in, obj); } } - return in; + *ret = in; } EAPI const char * -evas_object_type_get(const Evas_Object *obj) +evas_object_type_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - if (obj->delete_me) return ""; - return obj->type; + const char *type = NULL; + eo_do((Eo *)eo_obj, evas_obj_type_get(&type)); + return type; +} + +static void +_type_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + const char **type = va_arg(*list, const char **); + if (obj->delete_me) + { + if (type) *type = ""; + return; + } + if (type) *type = obj->type; +} + +static void +_type_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + const char *type = va_arg(*list, const char *); + obj->type = type; // Store it as the top type of this class + // Need to add this type to the list of all the types supported + obj->supported_types = eina_list_append(obj->supported_types, type); } EAPI void -evas_object_precise_is_inside_set(Evas_Object *obj, Eina_Bool precise) +evas_object_precise_is_inside_set(Evas_Object *eo_obj, Eina_Bool precise) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_precise_is_inside_set(precise)); +} + +static void +_precise_is_inside_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + Eina_Bool precise = va_arg(*list, int); obj->precise_is_inside = precise; } EAPI Eina_Bool -evas_object_precise_is_inside_get(const Evas_Object *obj) +evas_object_precise_is_inside_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - return obj->precise_is_inside; + Eina_Bool precise = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_precise_is_inside_get(&precise)); + return precise; +} + +static void +_precise_is_inside_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Eina_Bool *precise = va_arg(*list, Eina_Bool *); + if (precise) *precise = obj->precise_is_inside; } EAPI void -evas_object_static_clip_set(Evas_Object *obj, Eina_Bool is_static_clip) +evas_object_static_clip_set(Evas_Object *eo_obj, Eina_Bool is_static_clip) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_static_clip_set(is_static_clip)); +} + +static void +_static_clip_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + Eina_Bool is_static_clip = va_arg(*list, int); obj->is_static_clip = is_static_clip; } EAPI Eina_Bool -evas_object_static_clip_get(const Evas_Object *obj) +evas_object_static_clip_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return 0; MAGIC_CHECK_END(); - return obj->is_static_clip; + Eina_Bool is_static_clip = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_static_clip_get(&is_static_clip)); + return is_static_clip; +} + +static void +_static_clip_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Eina_Bool *is_static_clip = va_arg(*list, Eina_Bool *); + if (is_static_clip) *is_static_clip = obj->is_static_clip; } EAPI void -evas_object_is_frame_object_set(Evas_Object *obj, Eina_Bool is_frame) +evas_object_is_frame_object_set(Evas_Object *eo_obj, Eina_Bool is_frame) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_is_frame_object_set(is_frame)); +} + +static void +_is_frame_object_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = _pd; + Eina_Bool is_frame = va_arg(*list, int); obj->is_frame = is_frame; } EAPI Eina_Bool -evas_object_is_frame_object_get(Evas_Object *obj) +evas_object_is_frame_object_get(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - return obj->is_frame; + Eina_Bool is_frame = EINA_FALSE; + eo_do(eo_obj, evas_obj_is_frame_object_get(&is_frame)); + return is_frame; } + +static void +_is_frame_object_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Eina_Bool *is_frame = va_arg(*list, Eina_Bool *); + if (is_frame) *is_frame = obj->is_frame; +} + +static void +_smart_parent_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object **smart_parent = va_arg(*list, Evas_Object **); + if (smart_parent) *smart_parent = obj->smart.parent; +} + +static void +_smart_data_get(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + void **data = va_arg(*list, void **); + *data = NULL; +} + +static void +_type_check(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + const char *type = va_arg(*list, const char *); + Eina_Bool *type_check = va_arg(*list, Eina_Bool *); + if (0 == strcmp(type, "Evas_Object")) + *type_check = EINA_TRUE; + else + *type_check = EINA_FALSE; +} + +static void +_smart_type_check(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + const char *type = va_arg(*list, const char *); + Eina_Bool *type_check = va_arg(*list, Eina_Bool *); + + const Evas_Smart_Class *sc; + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!obj->is_smart) + { + *type_check = EINA_FALSE; + return; + } + + if (obj->supported_types) + { + Eina_List *l; + const char *type_in_list; + EINA_LIST_FOREACH(obj->supported_types, l, type_in_list) + if (!strcmp(type_in_list, type)) + { + *type_check = EINA_TRUE; + return; + } + } + + eo_do((Eo *)eo_obj, evas_obj_type_check(type, type_check)); + + if (EINA_FALSE == *type_check) + { + if (obj->smart.smart) + { + sc = obj->smart.smart->smart_class; + while (sc) + { + if (!strcmp(sc->name, type)) + { + *type_check = EINA_TRUE; + return; + } + sc = sc->parent; + } + } + } + + *type_check = EINA_FALSE; +} + +static void +_smart_type_check_ptr(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + const Evas_Smart_Class *sc; + const char* type = va_arg(*list, const char *); + Eina_Bool *type_check = va_arg(*list, Eina_Bool *); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!obj->is_smart) + { + if (type_check) *type_check = EINA_FALSE; + return; + } + + eo_do((Eo *)eo_obj, evas_obj_type_check(type, type_check)); + + if (EINA_FALSE == *type_check) + { + if (obj->smart.smart) + { + sc = obj->smart.smart->smart_class; + while (sc) + { + if (sc->name == type) + { + if (type_check) *type_check = EINA_TRUE; + return; + } + sc = sc->parent; + } + } + } + + if (type_check) *type_check = EINA_FALSE; +} + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_COMMON_ID(EVAS_COMMON_SUB_ID_EVAS_GET), _evas_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POSITION_SET), _position_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POSITION_GET), _position_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_SET), _size_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_GET), _size_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_SET), _size_hint_min_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_GET), _size_hint_min_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_SET), _size_hint_max_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_GET), _size_hint_max_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_SET), _size_hint_request_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_GET), _size_hint_request_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_SET), _size_hint_aspect_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_GET), _size_hint_aspect_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_SET), _size_hint_align_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_GET), _size_hint_align_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_SET), _size_hint_weight_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_GET), _size_hint_weight_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_SET), _size_hint_padding_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_GET), _size_hint_padding_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_VISIBILITY_SET), _visible_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_VISIBILITY_GET), _visible_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_COLOR_SET), _color_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_COLOR_GET), _color_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_ANTI_ALIAS_SET), _anti_alias_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_ANTI_ALIAS_GET), _anti_alias_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SCALE_SET), _scale_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SCALE_GET), _scale_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_RENDER_OP_SET), _render_op_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_RENDER_OP_GET), _render_op_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_SET), _type_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_GET), _type_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_SET), _precise_is_inside_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_GET), _precise_is_inside_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STATIC_CLIP_SET), _static_clip_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STATIC_CLIP_GET), _static_clip_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_SET), _is_frame_object_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_GET), _is_frame_object_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FREEZE_EVENTS_SET), _freeze_events_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FREEZE_EVENTS_GET), _freeze_events_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PASS_EVENTS_SET), _pass_events_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PASS_EVENTS_GET), _pass_events_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_REPEAT_EVENTS_SET), _repeat_events_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_REPEAT_EVENTS_GET), _repeat_events_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_SET), _propagate_events_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_GET), _propagate_events_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POINTER_MODE_SET), _pointer_mode_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_POINTER_MODE_GET), _pointer_mode_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_KEY_GRAB), _key_grab), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_KEY_UNGRAB), _key_ungrab), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FOCUS_SET), _focus_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_FOCUS_GET), _focus_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_NAME_SET), _name_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_NAME_GET), _name_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_NAME_CHILD_FIND), _name_child_find), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_LAYER_SET), _layer_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_LAYER_GET), _layer_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIP_SET), _clip_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIP_GET), _clip_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIP_UNSET), _clip_unset), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_CLIPEES_GET), _clipees_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_ENABLE_SET), _map_enable_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_ENABLE_GET), _map_enable_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_SET), _map_set), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_MAP_GET), _map_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_PARENT_GET), _smart_parent_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_DATA_GET), _smart_data_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK), _smart_type_check), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK_PTR), _smart_type_check_ptr), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_MOVE_CHILDREN_RELATIVE), _smart_move_children_relative), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_CLIPPED_CLIPPER_GET), _smart_clipped_clipper_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_RAISE), _raise), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_LOWER), _lower), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STACK_ABOVE), _stack_above), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_STACK_BELOW), _stack_below), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_ABOVE_GET), _above_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_BELOW_GET), _below_get), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_CHECK), _type_check), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_POSITION_SET, "Set the position of an evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_POSITION_GET, "Get the position of an evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_SET, "Set the size of an evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_GET, "Get the size of an evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_SET, "Sets the hints for an object's minimum size."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_MIN_GET, "Retrieves the hints for an object's minimum size."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_SET, "Sets the hints for an object's maximum size."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_MAX_GET, "Retrieves the hints for an object's maximum size."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_SET, "Sets the hints for an object's optimum size."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_REQUEST_GET, "Retrieves the hints for an object's optimum size."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_SET, "Sets the hints for an object's aspect ratio."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_ASPECT_GET, "Retrieves the hints for an object's aspect ratio."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_SET, "Sets the hints for an object's alignment."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_ALIGN_GET, "Retrieves the hints for on object's alignment."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_SET, "Sets the hints for an object's weight."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_WEIGHT_GET, "Retrieves the hints for an object's weight."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_SET, "Sets the hints for an object's padding space."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SIZE_HINT_PADDING_GET, "Retrieves the hints for an object's padding space."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_VISIBILITY_SET, "Makes the given Evas object visible/invisible."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_VISIBILITY_GET, "Retrieves whether or not the given Evas object is visible."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_COLOR_SET, "Sets the general/main color of the given Evas object to the given"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_COLOR_GET, "Retrieves the general/main color of the given Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_ANTI_ALIAS_SET, "Sets whether or not the given Evas object is to be drawn anti-aliased."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_ANTI_ALIAS_GET, "Retrieves whether or not the given Evas object is to be drawn anti_aliased."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SCALE_SET, "Sets the scaling factor for an Evas object. Does not affect all"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SCALE_GET, "Retrieves the scaling factor for the given Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_RENDER_OP_SET, "Sets the render_op to be used for rendering the Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_RENDER_OP_GET, "Retrieves the current value of the operation used for rendering the Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_TYPE_SET, "Sets the type of the given Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_TYPE_GET, "Retrieves the type of the given Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_SET, "Set whether to use precise (usually expensive) point collision"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_PRECISE_IS_INSIDE_GET, "Determine whether an object is set to use precise point collision"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_STATIC_CLIP_SET, "Set a hint flag on the given Evas object that it's used as a static clipper."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_STATIC_CLIP_GET, "Get the static clipper hint flag for a given Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_SET, "Set whether an object is a frame object"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_IS_FRAME_OBJECT_GET, "Determine whether an object is a frame object"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_FREEZE_EVENTS_SET, "Set whether an Evas object is to freeze (discard) events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_FREEZE_EVENTS_GET, "Determine whether an object is set to freeze (discard) events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_PASS_EVENTS_SET, "Set whether an Evas object is to pass (ignore) events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_PASS_EVENTS_GET, "Determine whether an object is set to pass (ignore) events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_REPEAT_EVENTS_SET, "Set whether an Evas object is to repeat events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_REPEAT_EVENTS_GET, "Determine whether an object is set to repeat events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_SET, "Set whether events on a smart object's member should get propagated"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_PROPAGATE_EVENTS_GET, "Retrieve whether an Evas object is set to propagate events."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_POINTER_MODE_SET, "Set pointer behavior."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_POINTER_MODE_GET, "Determine how pointer will behave."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_KEY_GRAB, "Requests keyname key events be directed to obj."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_KEY_UNGRAB, "Removes the grab on @p keyname key events by obj."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_FOCUS_SET, "Sets or unsets a given object as the currently focused one on its"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_FOCUS_GET, "Retrieve whether an object has the focus."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_NAME_SET, "Sets the name of the given Evas object to the given name."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_NAME_GET, "Retrieves the name of the given Evas object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_NAME_CHILD_FIND, "Retrieves the object from children of the given object with the given name."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_LAYER_SET, "Sets the layer of its canvas that the given object will be part of."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_LAYER_GET, "Retrieves the layer of its canvas that the given object is part of."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_CLIP_SET, "Clip one object to another."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_CLIP_GET, "Get the object clipping obj (if any)."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_CLIP_UNSET, "Disable/cease clipping on a clipped obj object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_CLIPEES_GET, "Return a list of objects currently clipped by obj."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_MAP_ENABLE_SET, "Enable or disable the map that is set."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_MAP_ENABLE_GET, "Get the map enabled state"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_MAP_SET, "Set current object transformation map."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_MAP_GET, "Get current object transformation map."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SMART_PARENT_GET, "Get the smart parent"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SMART_DATA_GET, "Get the smart data of obj"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK, "Checks whether a given smart object or any of its smart object"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SMART_TYPE_CHECK_PTR, "Checks whether a given smart object or any of its smart object"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SMART_MOVE_CHILDREN_RELATIVE, "Moves all children objects of a given smart object relative to a given offset"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_SMART_CLIPPED_CLIPPER_GET, "Get the clipper object for the given clipped smart object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_RAISE, "Raise obj to the top of its layer."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_LOWER, "Lower obj to the bottom of its layer."), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_STACK_ABOVE, "Stack obj immediately above above"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_STACK_BELOW, "Stack obj immediately below below"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_ABOVE_GET, "Get the Evas object stacked right above obj"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_BELOW_GET, "Get the Evas object stacked right below obj"), + EO_OP_DESCRIPTION(EVAS_OBJ_SUB_ID_TYPE_CHECK, "description here"), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + MY_CLASS_NAME, + EO_CLASS_TYPE_REGULAR_NO_INSTANT, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_BASE_ID, op_desc, EVAS_OBJ_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Protected_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_class_get, &class_desc, EO_BASE_CLASS, EVAS_COMMON_CLASS, NULL) + diff --git a/legacy/evas/src/lib/canvas/evas_object_polygon.c b/legacy/evas/src/lib/canvas/evas_object_polygon.c index 34931b2c06..b3df079f89 100644 --- a/legacy/evas/src/lib/canvas/evas_object_polygon.c +++ b/legacy/evas/src/lib/canvas/evas_object_polygon.c @@ -1,6 +1,12 @@ #include "evas_common.h" #include "evas_private.h" +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_POLYGON_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_POLYGON_CLASS + /* private magic number for polygon objects */ static const char o_type[] = "polygon"; @@ -10,7 +16,6 @@ typedef struct _Evas_Polygon_Point Evas_Polygon_Point; struct _Evas_Object_Polygon { - DATA32 magic; Eina_List *points; void *engine_data; struct { @@ -26,21 +31,20 @@ struct _Evas_Polygon_Point }; /* private methods for polygon objects */ -static void evas_object_polygon_init(Evas_Object *obj); -static void *evas_object_polygon_new(void); -static void evas_object_polygon_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_polygon_free(Evas_Object *obj); -static void evas_object_polygon_render_pre(Evas_Object *obj); -static void evas_object_polygon_render_post(Evas_Object *obj); +static void evas_object_polygon_init(Evas_Object *eo_obj); +static void evas_object_polygon_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_polygon_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_polygon_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_polygon_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_polygon_id_get(Evas_Object *obj); -static unsigned int evas_object_polygon_visual_id_get(Evas_Object *obj); -static void *evas_object_polygon_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_polygon_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_polygon_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_polygon_engine_data_get(Evas_Object *eo_obj); -static int evas_object_polygon_is_opaque(Evas_Object *obj); -static int evas_object_polygon_was_opaque(Evas_Object *obj); -static int evas_object_polygon_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); -static int evas_object_polygon_was_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); +static int evas_object_polygon_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_polygon_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_polygon_is_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y); +static int evas_object_polygon_was_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord x, Evas_Coord y); static const Evas_Object_Func object_func = { @@ -71,43 +75,53 @@ static const Evas_Object_Func object_func = /* the actual api call to add a rect */ /* it has no other api calls as all properties are standard */ -EVAS_MEMPOOL(_mp_obj); - EAPI Evas_Object * evas_object_polygon_add(Evas *e) { - Evas_Object *obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - obj = evas_object_new(e); - evas_object_polygon_init(obj); - evas_object_inject(obj, e); - return obj; + Evas_Object *eo_obj = eo_add(EVAS_OBJ_POLYGON_CLASS, e); + eo_unref(eo_obj); + return eo_obj; +} + +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_polygon_init(eo_obj); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); } EAPI void -evas_object_polygon_point_add(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_polygon_point_add(Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y) { - Evas_Object_Polygon *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_polygon_point_add(x, y)); +} + +static void +_polygon_point_add(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Polygon *o = _pd; Evas_Polygon_Point *p; Evas_Coord min_x, max_x, min_y, max_y; int is, was = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Polygon *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Polygon, MAGIC_OBJ_POLYGON); - return; - MAGIC_CHECK_END(); + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); - if (obj->layer->evas->events_frozen <= 0) + if (!obj->layer->evas->is_frozen) { - if (!evas_event_passes_through(obj) && - !evas_event_freezes_through(obj)) - was = evas_object_is_in_output_rect(obj, + if (!evas_event_passes_through(eo_obj, obj) && + !evas_event_freezes_through(eo_obj, obj)) + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); @@ -166,43 +180,46 @@ evas_object_polygon_point_add(Evas_Object *obj, Evas_Coord x, Evas_Coord y) //// obj->cur.cache.geometry.validity = 0; o->changed = EINA_TRUE; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_coords_recalc(obj); - if (obj->layer->evas->events_frozen <= 0) + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + if (!obj->layer->evas->is_frozen) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); - if (!evas_event_passes_through(obj) && - !evas_event_freezes_through(obj) ) + if (!evas_event_passes_through(eo_obj, obj) && + !evas_event_freezes_through(eo_obj, obj) ) { if ((is ^ was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } } - evas_object_inform_call_move(obj); - evas_object_inform_call_resize(obj); + evas_object_inform_call_move(eo_obj, obj); + evas_object_inform_call_resize(eo_obj); } EAPI void -evas_object_polygon_points_clear(Evas_Object *obj) +evas_object_polygon_points_clear(Evas_Object *eo_obj) { - Evas_Object_Polygon *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_polygon_points_clear()); +} + +static void +_polygon_points_clear(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Polygon *o = _pd; int is, was; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Polygon *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Polygon, MAGIC_OBJ_POLYGON); - return; - MAGIC_CHECK_END(); - was = evas_object_is_in_output_rect(obj, + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); while (o->points) @@ -216,28 +233,27 @@ evas_object_polygon_points_clear(Evas_Object *obj) obj->cur.geometry.h = 0; //// obj->cur.cache.geometry.validity = 0; o->changed = EINA_TRUE; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_coords_recalc(obj); - is = evas_object_is_in_output_rect(obj, + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is || was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); - evas_object_inform_call_move(obj); - evas_object_inform_call_resize(obj); + evas_object_inform_call_move(eo_obj, obj); + evas_object_inform_call_resize(eo_obj); } /* all nice and private */ static void -evas_object_polygon_init(Evas_Object *obj) +evas_object_polygon_init(Evas_Object *eo_obj) { - /* alloc image ob, setup methods and default values */ - obj->object_data = evas_object_polygon_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -255,30 +271,18 @@ evas_object_polygon_init(Evas_Object *obj) obj->type = o_type; } -static void * -evas_object_polygon_new(void) +static void +_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - Evas_Object_Polygon *o; - - /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_polygon", Evas_Object_Polygon, 4, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Polygon); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Polygon); - o->magic = MAGIC_OBJ_POLYGON; - return o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_polygon_free(eo_obj, obj); + eo_do_super(eo_obj, eo_destructor()); } static void -evas_object_polygon_free(Evas_Object *obj) +evas_object_polygon_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Polygon *o; - - /* frees private object data. very simple here */ - o = (Evas_Object_Polygon *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Polygon, MAGIC_OBJ_POLYGON); - return; - MAGIC_CHECK_END(); + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); /* free obj */ while (o->points) { @@ -288,19 +292,16 @@ evas_object_polygon_free(Evas_Object *obj) o->engine_data = obj->layer->evas->engine.func->polygon_points_clear(obj->layer->evas->engine.data.output, obj->layer->evas->engine.data.context, o->engine_data); - o->magic = 0; - EVAS_MEMPOOL_FREE(_mp_obj, o); } static void -evas_object_polygon_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_polygon_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { - Evas_Object_Polygon *o; + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); Eina_List *l; Evas_Polygon_Point *p; /* render object to surface with context, and offxet by x,y */ - o = (Evas_Object_Polygon *)(obj->object_data); obj->layer->evas->engine.func->context_color_set(output, context, obj->cur.cache.clip.r, @@ -336,9 +337,9 @@ evas_object_polygon_render(Evas_Object *obj, void *output, void *context, void * } static void -evas_object_polygon_render_pre(Evas_Object *obj) +evas_object_polygon_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Polygon *o; + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); int is_v, was_v; /* dont pre-render the obj twice! */ @@ -349,43 +350,44 @@ evas_object_polygon_render_pre(Evas_Object *obj) /* elsewhere, decoding video etc. */ /* then when this is done the object needs to figure if it changed and */ /* if so what and where and add the appropriate redraw lines */ - o = (Evas_Object_Polygon *)(obj->object_data); /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + evas_object_clip_recalc(obj->cur.clipper, cur_clipper); + cur_clipper->func->render_pre(obj->cur.clipper, cur_clipper); } /* now figure what changed and add draw rects */ /* if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); if (is_v != was_v) { - evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); goto done; } if (obj->changed_map) + if ((obj->cur.map != obj->prev.map) || + (obj->cur.usemap != obj->prev.usemap)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* it's not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj); /* if we restacked (layer or just within a layer) */ if (obj->restack) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed render op */ if (obj->cur.render_op != obj->prev.render_op) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed color */ @@ -394,7 +396,7 @@ evas_object_polygon_render_pre(Evas_Object *obj) (obj->cur.color.b != obj->prev.color.b) || (obj->cur.color.a != obj->prev.color.a)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed geometry - and obviously not visibility or color */ @@ -406,7 +408,7 @@ evas_object_polygon_render_pre(Evas_Object *obj) (obj->cur.geometry.h != obj->prev.geometry.h) || (o->changed)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } done: @@ -424,54 +426,46 @@ evas_object_polygon_render_pre(Evas_Object *obj) o->offset.y += obj->cur.geometry.y - o->geometry.y; } } - evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); } static void -evas_object_polygon_render_post(Evas_Object *obj) +evas_object_polygon_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { - Evas_Object_Polygon *o; + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); /* this moves the current data to the previous state parts of the object */ /* in whatever way is safest for the object. also if we don't need object */ /* data anymore we can free it if the object deems this is a good idea */ - o = (Evas_Object_Polygon *)(obj->object_data); /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); o->changed = 0; } -static unsigned int evas_object_polygon_id_get(Evas_Object *obj) +static unsigned int evas_object_polygon_id_get(Evas_Object *eo_obj) { - Evas_Object_Polygon *o; - - o = (Evas_Object_Polygon *)(obj->object_data); + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_POLYGON; } -static unsigned int evas_object_polygon_visual_id_get(Evas_Object *obj) +static unsigned int evas_object_polygon_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Polygon *o; - - o = (Evas_Object_Polygon *)(obj->object_data); + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_SHAPE; } -static void *evas_object_polygon_engine_data_get(Evas_Object *obj) +static void *evas_object_polygon_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Polygon *o; - - o = (Evas_Object_Polygon *)(obj->object_data); - if (!o) return NULL; + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); return o->engine_data; } static int -evas_object_polygon_is_opaque(Evas_Object *obj __UNUSED__) +evas_object_polygon_is_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object is */ /* currently fully opaque over the entire line it occupies */ @@ -479,7 +473,7 @@ evas_object_polygon_is_opaque(Evas_Object *obj __UNUSED__) } static int -evas_object_polygon_was_opaque(Evas_Object *obj __UNUSED__) +evas_object_polygon_was_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object was */ /* previously fully opaque over the entire line it occupies */ @@ -490,15 +484,13 @@ evas_object_polygon_was_opaque(Evas_Object *obj __UNUSED__) * intersects with. If it's even, we are outside of the polygon, if it's odd, * we are inside of it. */ static int -evas_object_polygon_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_polygon_is_inside(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED, Evas_Coord x, Evas_Coord y) { - Evas_Object_Polygon *o; + Evas_Object_Polygon *o = eo_data_get(eo_obj, MY_CLASS); int num_edges = 0; /* Number of edges we crossed */ Eina_List *itr; Evas_Polygon_Point *p; - o = (Evas_Object_Polygon *)(obj->object_data); - if (!o) return 0; if (!o->points) return 0; /* Adjust X and Y according to current geometry */ @@ -545,10 +537,44 @@ evas_object_polygon_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y) } static int -evas_object_polygon_was_inside(Evas_Object *obj __UNUSED__, Evas_Coord x __UNUSED__, Evas_Coord y __UNUSED__) +evas_object_polygon_was_inside(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED, Evas_Coord x EINA_UNUSED, Evas_Coord y EINA_UNUSED) { /* this returns 1 if the canvas co-ordinates were inside the object based */ /* on object private data. not much use for rects, but for polys, images */ /* and other complex objects it might be */ return 1; } + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_OBJ_POLYGON_ID(EVAS_OBJ_POLYGON_SUB_ID_POINT_ADD), _polygon_point_add), + EO_OP_FUNC(EVAS_OBJ_POLYGON_ID(EVAS_OBJ_POLYGON_SUB_ID_POINTS_CLEAR), _polygon_points_clear), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_POLYGON_SUB_ID_POINT_ADD, "Adds the given point to the given evas polygon object."), + EO_OP_DESCRIPTION(EVAS_OBJ_POLYGON_SUB_ID_POINTS_CLEAR, "Removes all of the points from the given evas polygon object."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Polygon", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_POLYGON_BASE_ID, op_desc, EVAS_OBJ_POLYGON_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Polygon), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_polygon_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_rectangle.c b/legacy/evas/src/lib/canvas/evas_object_rectangle.c index fa90f42b1c..07a720f613 100644 --- a/legacy/evas/src/lib/canvas/evas_object_rectangle.c +++ b/legacy/evas/src/lib/canvas/evas_object_rectangle.c @@ -1,6 +1,12 @@ #include "evas_common.h" #include "evas_private.h" +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_RECTANGLE_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_RECTANGLE_CLASS + /* private magic number for rectangle objects */ static const char o_type[] = "rectangle"; @@ -11,38 +17,35 @@ typedef struct _Evas_Object_Rectangle Evas_Object_Rectangle; struct _Evas_Object_Rectangle { - DATA32 magic; void *engine_data; }; /* private methods for rectangle objects */ -static void evas_object_rectangle_init(Evas_Object *obj); -static void *evas_object_rectangle_new(void); -static void evas_object_rectangle_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_rectangle_free(Evas_Object *obj); -static void evas_object_rectangle_render_pre(Evas_Object *obj); -static void evas_object_rectangle_render_post(Evas_Object *obj); +static void evas_object_rectangle_init(Evas_Object *eo_obj); +static void evas_object_rectangle_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_rectangle_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_rectangle_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_rectangle_id_get(Evas_Object *obj); -static unsigned int evas_object_rectangle_visual_id_get(Evas_Object *obj); -static void *evas_object_rectangle_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_rectangle_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_rectangle_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_rectangle_engine_data_get(Evas_Object *eo_obj); -static int evas_object_rectangle_is_opaque(Evas_Object *obj); -static int evas_object_rectangle_was_opaque(Evas_Object *obj); +static int evas_object_rectangle_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_rectangle_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); #if 0 /* usless calls for a rect object. much more useful for images etc. */ -static void evas_object_rectangle_store(Evas_Object *obj); -static void evas_object_rectangle_unstore(Evas_Object *obj); -static int evas_object_rectangle_is_visible(Evas_Object *obj); -static int evas_object_rectangle_was_visible(Evas_Object *obj); -static int evas_object_rectangle_is_inside(Evas_Object *obj, double x, double y); -static int evas_object_rectangle_was_inside(Evas_Object *obj, double x, double y); +static void evas_object_rectangle_store(Evas_Object *eo_obj); +static void evas_object_rectangle_unstore(Evas_Object *eo_obj); +static int evas_object_rectangle_is_visible(Evas_Object *eo_obj); +static int evas_object_rectangle_was_visible(Evas_Object *eo_obj); +static int evas_object_rectangle_is_inside(Evas_Object *eo_obj, double x, double y); +static int evas_object_rectangle_was_inside(Evas_Object *eo_obj, double x, double y); #endif static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_rectangle_free, + NULL, evas_object_rectangle_render, evas_object_rectangle_render_pre, evas_object_rectangle_render_post, @@ -68,28 +71,32 @@ static const Evas_Object_Func object_func = /* the actual api call to add a rect */ /* it has no other api calls as all properties are standard */ -EVAS_MEMPOOL(_mp_obj); - EAPI Evas_Object * evas_object_rectangle_add(Evas *e) { - Evas_Object *obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - obj = evas_object_new(e); - evas_object_rectangle_init(obj); - evas_object_inject(obj, e); - return obj; + Evas_Object *eo_obj = eo_add(EVAS_OBJ_RECTANGLE_CLASS, e); + eo_unref(eo_obj); + return eo_obj; +} + +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_rectangle_init(eo_obj); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); } /* all nice and private */ static void -evas_object_rectangle_init(Evas_Object *obj) +evas_object_rectangle_init(Evas_Object *eo_obj) { - /* alloc image ob, setup methods and default values */ - obj->object_data = evas_object_rectangle_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -108,37 +115,14 @@ evas_object_rectangle_init(Evas_Object *obj) obj->type = o_type; } -static void * -evas_object_rectangle_new(void) +static void +_destructor(Eo *eo_obj, void *_obj EINA_UNUSED, va_list *list EINA_UNUSED) { - Evas_Object_Rectangle *o; - - /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_rectangle", Evas_Object_Rectangle, 16, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Rectangle); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Rectangle); - o->magic = MAGIC_OBJ_RECTANGLE; - return o; + eo_do_super(eo_obj, eo_destructor()); } static void -evas_object_rectangle_free(Evas_Object *obj) -{ - Evas_Object_Rectangle *o; - - /* frees private object data. very simple here */ - o = (Evas_Object_Rectangle *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Rectangle, MAGIC_OBJ_RECTANGLE); - return; - MAGIC_CHECK_END(); - /* free obj */ - o->magic = 0; - EVAS_MEMPOOL_FREE(_mp_obj, o); -} - -static void -evas_object_rectangle_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_rectangle_render(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { /* render object to surface with context, and offxet by x,y */ obj->layer->evas->engine.func->context_color_set(output, @@ -165,7 +149,7 @@ evas_object_rectangle_render(Evas_Object *obj, void *output, void *context, void } static void -evas_object_rectangle_render_pre(Evas_Object *obj) +evas_object_rectangle_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { int is_v, was_v; @@ -180,40 +164,40 @@ evas_object_rectangle_render_pre(Evas_Object *obj) /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { - if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + Evas_Object_Protected_Data *cur_clipper_obj = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + if (obj->cur.cache.clip.dirty) + evas_object_clip_recalc(obj->cur.clipper, cur_clipper_obj); + cur_clipper_obj->func->render_pre(obj->cur.clipper, cur_clipper_obj); } /* now figure what changed and add draw rects */ /* if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj,obj); if (!(is_v | was_v)) goto done; if (is_v != was_v) { - evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); goto done; } if (obj->changed_map) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* it's not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj); /* if we restacked (layer or just within a layer) and don't clip anyone */ if ((obj->restack) && (!obj->clip.clipees)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed render op */ if (obj->cur.render_op != obj->prev.render_op) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed color */ @@ -222,7 +206,7 @@ evas_object_rectangle_render_pre(Evas_Object *obj) (obj->cur.color.b != obj->prev.color.b) || (obj->cur.color.a != obj->prev.color.a)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed geometry - and obviously not visibility or color */ @@ -256,8 +240,8 @@ evas_object_rectangle_render_pre(Evas_Object *obj) /* area so if there were updates for it they get wiped. don't do it if we */ /* arent fully opaque and we are visible */ /* - if (evas_object_is_visible(obj) && - evas_object_is_opaque(obj) && + if (evas_object_is_visible(eo_obj) && + evas_object_is_opaque(eo_obj) && (!obj->clip.clipees)) obj->layer->evas->engine.func->output_redraws_rect_del(obj->layer->evas->engine.data.output, obj->cur.cache.clip.x, @@ -266,24 +250,24 @@ evas_object_rectangle_render_pre(Evas_Object *obj) obj->cur.cache.clip.h); */ done: - evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); } static void -evas_object_rectangle_render_post(Evas_Object *obj) +evas_object_rectangle_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this moves the current data to the previous state parts of the object */ /* in whatever way is safest for the object. also if we don't need object */ /* data anymore we can free it if the object deems this is a good idea */ /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); } static int -evas_object_rectangle_is_opaque(Evas_Object *obj) +evas_object_rectangle_is_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { /* this returns 1 if the internal object data implies that the object is */ /* currently fully opaque over the entire rectangle it occupies */ @@ -296,7 +280,7 @@ evas_object_rectangle_is_opaque(Evas_Object *obj) } static int -evas_object_rectangle_was_opaque(Evas_Object *obj) +evas_object_rectangle_was_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj) { /* this returns 1 if the internal object data implies that the object was */ /* previously fully opaque over the entire rectangle it occupies */ @@ -307,37 +291,59 @@ evas_object_rectangle_was_opaque(Evas_Object *obj) return 1; } -static unsigned int evas_object_rectangle_id_get(Evas_Object *obj) +static unsigned int evas_object_rectangle_id_get(Evas_Object *eo_obj) { - Evas_Object_Rectangle *o; - - o = (Evas_Object_Rectangle *)(obj->object_data); + Evas_Object_Rectangle *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_RECTANGLE; } -static unsigned int evas_object_rectangle_visual_id_get(Evas_Object *obj) +static unsigned int evas_object_rectangle_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Rectangle *o; - - o = (Evas_Object_Rectangle *)(obj->object_data); + Evas_Object_Rectangle *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_SHAPE; } -static void *evas_object_rectangle_engine_data_get(Evas_Object *obj) +static void *evas_object_rectangle_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Rectangle *o; - - o = (Evas_Object_Rectangle *)(obj->object_data); - if (!o) return NULL; + Evas_Object_Rectangle *o = eo_data_get(eo_obj, MY_CLASS); return o->engine_data; } +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Rectangle", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_RECTANGLE_BASE_ID, op_desc, EVAS_OBJ_RECTANGLE_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Rectangle), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_rectangle_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); + #if 0 /* usless calls for a rect object. much more useful for images etc. */ static void -evas_object_rectangle_store(Evas_Object *obj) +evas_object_rectangle_store(Evas_Object *eo_obj) { /* store... nothing for rectangle objects... it's a bit silly */ /* but for others that may have expensive caluclations to do to */ @@ -346,13 +352,13 @@ evas_object_rectangle_store(Evas_Object *obj) } static void -evas_object_rectangle_unstore(Evas_Object *obj) +evas_object_rectangle_unstore(Evas_Object *eo_obj) { /* store... nothing for rectangle objects... it's a bit silly */ } static int -evas_object_rectangle_is_visible(Evas_Object *obj) +evas_object_rectangle_is_visible(Evas_Object *eo_obj) { /* this returns 1 if the internal object data would imply that it is */ /* visible (ie drawing it draws something. this is not to do with events */ @@ -360,7 +366,7 @@ evas_object_rectangle_is_visible(Evas_Object *obj) } static int -evas_object_rectangle_was_visible(Evas_Object *obj) +evas_object_rectangle_was_visible(Evas_Object *eo_obj) { /* this returns 1 if the internal object data would imply that it was */ /* visible (ie drawing it draws something. this is not to do with events */ @@ -368,7 +374,7 @@ evas_object_rectangle_was_visible(Evas_Object *obj) } static int -evas_object_rectangle_is_inside(Evas_Object *obj, double x, double y) +evas_object_rectangle_is_inside(Evas_Object *eo_obj, double x, double y) { /* this returns 1 if the canvas co-ordinates are inside the object based */ /* on object private data. not much use for rects, but for polys, images */ @@ -377,7 +383,7 @@ evas_object_rectangle_is_inside(Evas_Object *obj, double x, double y) } static int -evas_object_rectangle_was_inside(Evas_Object *obj, double x, double y) +evas_object_rectangle_was_inside(Evas_Object *eo_obj, double x, double y) { /* this returns 1 if the canvas co-ordinates were inside the object based */ /* on object private data. not much use for rects, but for polys, images */ diff --git a/legacy/evas/src/lib/canvas/evas_object_smart.c b/legacy/evas/src/lib/canvas/evas_object_smart.c index f1d934a814..338847ce04 100644 --- a/legacy/evas/src/lib/canvas/evas_object_smart.c +++ b/legacy/evas/src/lib/canvas/evas_object_smart.c @@ -1,16 +1,26 @@ #include "evas_common.h" #include "evas_private.h" +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_SMART_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_SMART_CLASS + +#define MY_CLASS_NAME "Evas_Object_Smart" + +extern Eina_Hash* signals_hash_table; + typedef struct _Evas_Object_Smart Evas_Object_Smart; typedef struct _Evas_Smart_Callback Evas_Smart_Callback; struct _Evas_Object_Smart { - DATA32 magic; void *engine_data; void *data; Eina_List *callbacks; Eina_Inlist *contained; + Eina_Inlist *smart_callbacks_infos; Evas_Smart_Cb_Description_Array callbacks_descriptions; int walking_list; int member_count; @@ -29,22 +39,20 @@ struct _Evas_Smart_Callback }; /* private methods for smart objects */ -static void evas_object_smart_callbacks_clear(Evas_Object *obj); -static void evas_object_smart_init(Evas_Object *obj); -static void *evas_object_smart_new(void); -static void evas_object_smart_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_smart_free(Evas_Object *obj); -static void evas_object_smart_render_pre(Evas_Object *obj); -static void evas_object_smart_render_post(Evas_Object *obj); +static void evas_object_smart_callbacks_clear(Evas_Object *eo_obj); +static void evas_object_smart_init(Evas_Object *eo_obj); +static void evas_object_smart_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_smart_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_smart_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_smart_id_get(Evas_Object *obj); -static unsigned int evas_object_smart_visual_id_get(Evas_Object *obj); -static void *evas_object_smart_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_smart_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_smart_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_smart_engine_data_get(Evas_Object *eo_obj); static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_smart_free, + NULL, evas_object_smart_render, evas_object_smart_render_pre, evas_object_smart_render_post, @@ -67,306 +75,323 @@ static const Evas_Object_Func object_func = NULL }; -EVAS_MEMPOOL(_mp_obj); -EVAS_MEMPOOL(_mp_cb); +EVAS_MEMPOOL(_mp_cb); /* public funcs */ EAPI void -evas_object_smart_data_set(Evas_Object *obj, void *data) +evas_object_smart_data_set(Evas_Object *eo_obj, void *data) { - Evas_Object_Smart *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_smart_data_set(data)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - return; - MAGIC_CHECK_END(); +static void +_smart_data_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + void *data = va_arg(*list, void *); + Evas_Object_Smart *o = _pd; o->data = data; } EAPI void * -evas_object_smart_data_get(const Evas_Object *obj) +evas_object_smart_data_get(const Evas_Object *eo_obj) { - Evas_Object_Smart *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - if (!o) return NULL; - if (o->magic != MAGIC_OBJ_SMART) return NULL; - return o->data; + void *data = NULL; + eo_do((Eo *)eo_obj, evas_obj_smart_data_get(&data)); + return data; +} + +static void +_smart_data_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Smart *o = _pd; + void **data = va_arg(*list, void **); + *data = o->data; } EAPI const void * -evas_object_smart_interface_get(const Evas_Object *obj, +evas_object_smart_interface_get(const Evas_Object *eo_obj, const char *name) { Evas_Smart *s; unsigned int i; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - s = evas_object_smart_smart_get(obj); + if (!eo_isa(eo_obj, EVAS_OBJ_SMART_CLASS)) return NULL; + + s = evas_object_smart_smart_get(eo_obj); if (!s) return NULL; - for (i = 0; i < s->interfaces.size; i++) + if (s) { - const Evas_Smart_Interface *iface; + for (i = 0; i < s->interfaces.size; i++) + { + const Evas_Smart_Interface *iface; - iface = s->interfaces.array[i]; + iface = s->interfaces.array[i]; - if (iface->name == name) - return iface; + if (iface->name == name) + return iface; + } } return NULL; } EAPI void * -evas_object_smart_interface_data_get(const Evas_Object *obj, +evas_object_smart_interface_data_get(const Evas_Object *eo_obj, const Evas_Smart_Interface *iface) { unsigned int i; Evas_Smart *s; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - s = evas_object_smart_smart_get(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + s = evas_object_smart_smart_get(eo_obj); if (!s) return NULL; - for (i = 0; i < s->interfaces.size; i++) + if (s) { - if (iface == s->interfaces.array[i]) - return obj->interface_privates[i]; + for (i = 0; i < s->interfaces.size; i++) + { + if (iface == s->interfaces.array[i]) + return obj->interface_privates[i]; + } } return NULL; } EAPI Evas_Smart * -evas_object_smart_smart_get(const Evas_Object *obj) +evas_object_smart_smart_get(const Evas_Object *eo_obj) { - Evas_Object_Smart *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + Evas_Smart *smart = NULL; + eo_do((Eo *)eo_obj, evas_obj_smart_smart_get(&smart)); + return smart; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - return NULL; - MAGIC_CHECK_END(); - return obj->smart.smart; +static void +_smart_smart_get(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart **smart = va_arg(*list, Evas_Smart **); + if (smart) *smart = obj->smart.smart; } EAPI void -evas_object_smart_member_add(Evas_Object *obj, Evas_Object *smart_obj) +evas_object_smart_member_add(Evas_Object *eo_obj, Evas_Object *smart_obj) { - Evas_Object_Smart *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(smart_obj, evas_obj_smart_member_add(eo_obj)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - MAGIC_CHECK(smart_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(smart_obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - return; - MAGIC_CHECK_END(); +static void +_smart_member_add(Eo *smart_obj, void *_pd, va_list *list) +{ + Evas_Object *eo_obj = va_arg(*list, Evas_Object *); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Protected_Data *smart = eo_data_get(smart_obj, EVAS_OBJ_CLASS); + Evas_Object_Smart *o = _pd; if (obj->delete_me) { - CRIT("Adding deleted object %p to smart obj %p", obj, smart_obj); + CRIT("Adding deleted object %p to smart obj %p", eo_obj, smart_obj); abort(); return; } - if (smart_obj->delete_me) + if (smart->delete_me) { - CRIT("Adding object %p to deleted smart obj %p", obj, smart_obj); + CRIT("Adding object %p to deleted smart obj %p", eo_obj, smart_obj); abort(); return; } - if (!smart_obj->layer) + if (!smart->layer) { CRIT("No evas surface associated with smart object (%p)", smart_obj); abort(); return; } - if ((obj->layer && smart_obj->layer) && - (obj->layer->evas != smart_obj->layer->evas)) + if ((obj->layer && smart->layer) && + (obj->layer->evas != smart->layer->evas)) { - CRIT("Adding object %p from Evas (%p) from another Evas (%p)", obj, obj->layer->evas, smart_obj->layer->evas); + CRIT("Adding object %p from Evas (%p) from another Evas (%p)", eo_obj, obj->layer->evas, smart->layer->evas); abort(); return; } if (obj->smart.parent == smart_obj) return; - if (obj->smart.parent) evas_object_smart_member_del(obj); + if (obj->smart.parent) evas_object_smart_member_del(eo_obj); o->member_count++; - evas_object_release(obj, 1); - obj->layer = smart_obj->layer; + evas_object_release(eo_obj, obj, 1); + obj->layer = smart->layer; obj->cur.layer = obj->layer->layer; obj->layer->usage++; obj->smart.parent = smart_obj; o->contained = eina_inlist_append(o->contained, EINA_INLIST_GET(obj)); - evas_object_smart_member_cache_invalidate(obj, EINA_TRUE, EINA_TRUE); + evas_object_smart_member_cache_invalidate(eo_obj, EINA_TRUE, EINA_TRUE); obj->restack = 1; - evas_object_change(obj); - evas_object_mapped_clip_across_mark(obj); - if (smart_obj->smart.smart->smart_class->member_add) - smart_obj->smart.smart->smart_class->member_add(smart_obj, obj); - evas_object_update_bounding_box(obj); + evas_object_change(eo_obj, obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); + if (smart->smart.smart && smart->smart.smart->smart_class->member_add) + smart->smart.smart->smart_class->member_add(smart_obj, eo_obj); + evas_object_update_bounding_box(eo_obj, obj); } EAPI void -evas_object_smart_member_del(Evas_Object *obj) +evas_object_smart_member_del(Evas_Object *eo_obj) { - Evas_Object_Smart *o; - Evas_Object *smart_obj; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!obj) return; + if (!obj->smart.parent) return; + Evas_Object *smart_obj = obj->smart.parent; + + eo_do(smart_obj, evas_obj_smart_member_del(eo_obj)); +} + +static void +_smart_member_del(Eo *smart_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object *eo_obj = va_arg(*list, Evas_Object *); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (!obj->smart.parent) return; - smart_obj = obj->smart.parent; - if (smart_obj->smart.smart->smart_class->member_del) - smart_obj->smart.smart->smart_class->member_del(smart_obj, obj); + Evas_Object_Protected_Data *smart = eo_data_get(smart_obj, EVAS_OBJ_CLASS); + if (smart->smart.smart && smart->smart.smart->smart_class->member_del) + smart->smart.smart->smart_class->member_del(smart_obj, eo_obj); - o = (Evas_Object_Smart *)(obj->smart.parent->object_data); + Evas_Object_Smart *o = eo_data_get(smart_obj, MY_CLASS); o->contained = eina_inlist_remove(o->contained, EINA_INLIST_GET(obj)); o->member_count--; obj->smart.parent = NULL; - evas_object_smart_member_cache_invalidate(obj, EINA_TRUE, EINA_TRUE); + evas_object_smart_member_cache_invalidate(eo_obj, EINA_TRUE, EINA_TRUE); obj->layer->usage--; obj->cur.layer = obj->layer->layer; - evas_object_inject(obj, obj->layer->evas); + evas_object_inject(eo_obj, obj, obj->layer->evas->evas); obj->restack = 1; - evas_object_change(obj); - evas_object_mapped_clip_across_mark(obj); + evas_object_change(eo_obj, obj); + evas_object_mapped_clip_across_mark(eo_obj, obj); } EAPI Evas_Object * -evas_object_smart_parent_get(const Evas_Object *obj) +evas_object_smart_parent_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object *smart_parent = NULL; + eo_do((Eo *)eo_obj, evas_obj_smart_parent_get(&smart_parent)); + return smart_parent; +} - return obj->smart.parent; +static void +_type_check(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + const char *type = va_arg(*list, const char *); + Eina_Bool *type_check = va_arg(*list, Eina_Bool *); + if (0 == strcmp(type, "Evas_Object_Smart")) + *type_check = EINA_TRUE; + else + eo_do_super(eo_obj, evas_obj_type_check(type, type_check)); } EAPI Eina_Bool -evas_object_smart_type_check(const Evas_Object *obj, const char *type) +evas_object_smart_type_check(const Evas_Object *eo_obj, const char *type) { - const Evas_Smart_Class *sc; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - - EINA_SAFETY_ON_FALSE_RETURN_VAL(type, EINA_FALSE); - - if (!obj->smart.smart) - return EINA_FALSE; - sc = obj->smart.smart->smart_class; - while (sc) - { - if (!strcmp(sc->name, type)) - return EINA_TRUE; - sc = sc->parent; - } - - return EINA_FALSE; + Eina_Bool type_check = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_smart_type_check(type, &type_check)); + return type_check; } EAPI Eina_Bool -evas_object_smart_type_check_ptr(const Evas_Object *obj, const char *type) +evas_object_smart_type_check_ptr(const Evas_Object *eo_obj, const char *type) { - const Evas_Smart_Class *sc; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); - - EINA_SAFETY_ON_FALSE_RETURN_VAL(type, EINA_FALSE); - - if (!obj->smart.smart) - return EINA_FALSE; - sc = obj->smart.smart->smart_class; - while (sc) - { - if (sc->name == type) - return EINA_TRUE; - sc = sc->parent; - } - - return EINA_FALSE; + Eina_Bool type_check_ptr = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_smart_type_check_ptr(type, &type_check_ptr)); + return type_check_ptr; } EAPI Eina_List * -evas_object_smart_members_get(const Evas_Object *obj) +evas_object_smart_members_get(const Evas_Object *eo_obj) { - Evas_Object_Smart *o; - Eina_List *members; - Eina_Inlist *member; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + if (!eo_isa(eo_obj, MY_CLASS)) return NULL; + Eina_List *list = NULL; + eo_do((Eo *)eo_obj, evas_obj_smart_members_get(&list)); + return list; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - if (!obj->smart.smart) return NULL; - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - return NULL; - MAGIC_CHECK_END(); +static void +_smart_members_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_List **members_list = va_arg(*list, Eina_List **); + const Evas_Object_Smart *o = _pd; + Eina_List *members; + + Eina_Inlist *member; members = NULL; for (member = o->contained; member; member = member->next) - members = eina_list_append(members, member); + members = eina_list_append(members, ((Evas_Object_Protected_Data *)member)->object); - return members; + *members_list = members; } const Eina_Inlist * -evas_object_smart_members_get_direct(const Evas_Object *obj) +evas_object_smart_members_get_direct(const Evas_Object *eo_obj) { - Evas_Object_Smart *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - if (!obj->smart.smart) return NULL; - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + if (!eo_isa(eo_obj, MY_CLASS)) return NULL; + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); return o->contained; } void -_evas_object_smart_members_all_del(Evas_Object *obj) +_evas_object_smart_members_all_del(Evas_Object *eo_obj) { - Evas_Object_Smart *o = (Evas_Object_Smart *)(obj->object_data); - Evas_Object *memobj; + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); + Evas_Object_Protected_Data *memobj; Eina_Inlist *itrn; EINA_INLIST_FOREACH_SAFE(o->contained, itrn, memobj) { - evas_object_del((Evas_Object *) memobj); + evas_object_del((Evas_Object *)((Evas_Object_Protected_Data *)memobj->object)); } } static void -_evas_smart_class_ifaces_private_data_alloc(Evas_Object *obj, +_evas_smart_class_ifaces_private_data_alloc(Evas_Object *eo_obj, Evas_Smart *s) { unsigned int i, total_priv_sz = 0; @@ -398,6 +423,7 @@ _evas_smart_class_ifaces_private_data_alloc(Evas_Object *obj, } } + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); obj->interface_privates = malloc (s->interfaces.size * sizeof(void *) + total_priv_sz); if (!obj->interface_privates) @@ -431,28 +457,139 @@ _evas_smart_class_ifaces_private_data_alloc(Evas_Object *obj, } EAPI Evas_Object * -evas_object_smart_add(Evas *e, Evas_Smart *s) +evas_object_smart_add(Evas *eo_e, Evas_Smart *s) { - Evas_Object *obj; - unsigned int i; + Evas_Object *eo_obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + eo_obj = eo_add(EVAS_OBJ_SMART_CLASS, eo_e); + eo_do(eo_obj, evas_obj_smart_attach(s)); + eo_unref(eo_obj); + return eo_obj; +} + +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); + evas_object_smart_init(eo_obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); + eo_do(eo_obj, + evas_obj_type_set(MY_CLASS_NAME), + evas_obj_smart_add()); +} + +static void +_smart_add(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->add) s->smart_class->add(eo_obj); +} + +static void +_smart_del(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ +} + +static void +_smart_resize(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->resize) s->smart_class->resize(eo_obj, w, h); +} + +static void +_smart_move(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->move) s->smart_class->move(eo_obj, x, y); +} + +static void +_smart_show(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->show) s->smart_class->show(eo_obj); +} + +static void +_smart_hide(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->hide) s->smart_class->hide(eo_obj); +} + +static void +_smart_color_set(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->color_set) s->smart_class->color_set(eo_obj, r, g, b, a); +} + +static void +_smart_clip_set(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object *clip = va_arg(*list, Evas_Object *); + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->clip_set) s->smart_class->clip_set(eo_obj, clip); +} + +static void +_smart_clip_unset(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + // If this function is reached, so we do nothing except trying to call + // the function of the legacy smart class. + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Smart *s = obj->smart.smart; + if (s && s->smart_class->clip_unset) s->smart_class->clip_unset(eo_obj); +} + +static void +_smart_attach(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Smart *s = va_arg(*list, Evas_Smart *); MAGIC_CHECK(s, Evas_Smart, MAGIC_SMART); - return NULL; + return; MAGIC_CHECK_END(); - - obj = evas_object_new(e); - if (!obj) return NULL; + unsigned int i; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); obj->smart.smart = s; obj->type = s->smart_class->name; - evas_object_smart_init(obj); - evas_object_inject(obj, e); - evas_object_smart_use(s); - _evas_smart_class_ifaces_private_data_alloc(obj, s); + _evas_smart_class_ifaces_private_data_alloc(eo_obj, s); for (i = 0; i < s->interfaces.size; i++) { @@ -461,18 +598,16 @@ evas_object_smart_add(Evas *e, Evas_Smart *s) iface = s->interfaces.array[i]; if (iface->add) { - if (!iface->add(obj)) + if (!iface->add(eo_obj)) { ERR("failed to create interface %s\n", iface->name); - evas_object_del(obj); - return NULL; + evas_object_del(eo_obj); + return; } } } - if (s->smart_class->add) s->smart_class->add(obj); - - return obj; + eo_do(eo_obj, evas_obj_smart_add()); } static int @@ -488,25 +623,22 @@ _callback_priority_cmp(const void *_a, const void *_b) } EAPI void -evas_object_smart_callback_add(Evas_Object *obj, const char *event, Evas_Smart_Cb func, const void *data) +evas_object_smart_callback_add(Evas_Object *eo_obj, const char *event, Evas_Smart_Cb func, const void *data) { - evas_object_smart_callback_priority_add(obj, event, + evas_object_smart_callback_priority_add(eo_obj, event, EVAS_CALLBACK_PRIORITY_DEFAULT, func, data); } EAPI void -evas_object_smart_callback_priority_add(Evas_Object *obj, const char *event, Evas_Callback_Priority priority, Evas_Smart_Cb func, const void *data) +evas_object_smart_callback_priority_add(Evas_Object *eo_obj, const char *event, Evas_Callback_Priority priority, Evas_Smart_Cb func, const void *data) { Evas_Object_Smart *o; Evas_Smart_Callback *cb; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + o = eo_data_get(eo_obj, MY_CLASS); if (!event) return; if (!func) return; EVAS_MEMPOOL_INIT(_mp_cb, "evas_smart_callback", Evas_Smart_Callback, 32, ); @@ -522,19 +654,17 @@ evas_object_smart_callback_priority_add(Evas_Object *obj, const char *event, Eva } EAPI void * -evas_object_smart_callback_del(Evas_Object *obj, const char *event, Evas_Smart_Cb func) +evas_object_smart_callback_del(Evas_Object *eo_obj, const char *event, Evas_Smart_Cb func) { Evas_Object_Smart *o; Eina_List *l; Evas_Smart_Callback *cb; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + o = eo_data_get(eo_obj, MY_CLASS); + if (!event) return NULL; EINA_LIST_FOREACH(o->callbacks, l, cb) { @@ -545,7 +675,7 @@ evas_object_smart_callback_del(Evas_Object *obj, const char *event, Evas_Smart_C data = cb->func_data; cb->delete_me = 1; o->deletions_waiting = 1; - evas_object_smart_callbacks_clear(obj); + evas_object_smart_callbacks_clear(eo_obj); return data; } } @@ -553,19 +683,16 @@ evas_object_smart_callback_del(Evas_Object *obj, const char *event, Evas_Smart_C } EAPI void * -evas_object_smart_callback_del_full(Evas_Object *obj, const char *event, Evas_Smart_Cb func, const void *data) +evas_object_smart_callback_del_full(Evas_Object *eo_obj, const char *event, Evas_Smart_Cb func, const void *data) { Evas_Object_Smart *o; Eina_List *l; Evas_Smart_Callback *cb; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + o = eo_data_get(eo_obj, MY_CLASS); if (!event) return NULL; EINA_LIST_FOREACH(o->callbacks, l, cb) { @@ -576,7 +703,7 @@ evas_object_smart_callback_del_full(Evas_Object *obj, const char *event, Evas_Sm ret = cb->func_data; cb->delete_me = 1; o->deletions_waiting = 1; - evas_object_smart_callbacks_clear(obj); + evas_object_smart_callbacks_clear(eo_obj); return ret; } } @@ -584,20 +711,19 @@ evas_object_smart_callback_del_full(Evas_Object *obj, const char *event, Evas_Sm } EAPI void -evas_object_smart_callback_call(Evas_Object *obj, const char *event, void *event_info) +evas_object_smart_callback_call(Evas_Object *eo_obj, const char *event, void *event_info) { Evas_Object_Smart *o; Eina_List *l; Evas_Smart_Callback *cb; const char *strshare; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + o = eo_data_get(eo_obj, MY_CLASS); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!event) return; if (obj->delete_me) return; o->walking_list++; @@ -607,75 +733,88 @@ evas_object_smart_callback_call(Evas_Object *obj, const char *event, void *event if (!cb->delete_me) { if (cb->event == strshare) - cb->func(cb->func_data, obj, event_info); + cb->func(cb->func_data, eo_obj, event_info); } if (obj->delete_me) break; } eina_stringshare_del(strshare); o->walking_list--; - evas_object_smart_callbacks_clear(obj); + evas_object_smart_callbacks_clear(eo_obj); + + const _Evas_Event_Description *event_desc = eina_hash_find(signals_hash_table, event); + if (event_desc) + eo_do(eo_obj, eo_event_callback_call(event_desc->eo_desc, event_info, NULL)); } EAPI Eina_Bool -evas_object_smart_callbacks_descriptions_set(Evas_Object *obj, const Evas_Smart_Cb_Description *descriptions) +evas_object_smart_callbacks_descriptions_set(Evas_Object *eo_obj, const Evas_Smart_Cb_Description *descriptions) { - const Evas_Smart_Cb_Description *d; - Evas_Object_Smart *o; - unsigned int i, count = 0; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EINA_FALSE; + MAGIC_CHECK_END(); + Eina_Bool result = EINA_FALSE; + eo_do(eo_obj, evas_obj_smart_callbacks_descriptions_set(descriptions, &result)); + return result; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - return EINA_FALSE; - MAGIC_CHECK_END(); +static void +_smart_callbacks_descriptions_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Smart_Cb_Description *descriptions = va_arg(*list, Evas_Smart_Cb_Description *); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + if (result) *result = EINA_TRUE; + + const Evas_Smart_Cb_Description *d; + Evas_Object_Smart *o = _pd; + unsigned int i, count = 0; if ((!descriptions) || (!descriptions->name)) { evas_smart_cb_descriptions_resize(&o->callbacks_descriptions, 0); - return EINA_TRUE; + return; } for (count = 0, d = descriptions; d->name; d++) count++; evas_smart_cb_descriptions_resize(&o->callbacks_descriptions, count); - if (count == 0) return EINA_TRUE; + if (count == 0) return; for (i = 0, d = descriptions; i < count; d++, i++) o->callbacks_descriptions.array[i] = d; evas_smart_cb_descriptions_fix(&o->callbacks_descriptions); - - return EINA_TRUE; } EAPI void -evas_object_smart_callbacks_descriptions_get(const Evas_Object *obj, const Evas_Smart_Cb_Description ***class_descriptions, unsigned int *class_count, const Evas_Smart_Cb_Description ***instance_descriptions, unsigned int *instance_count) +evas_object_smart_callbacks_descriptions_get(const Evas_Object *eo_obj, const Evas_Smart_Cb_Description ***class_descriptions, unsigned int *class_count, const Evas_Smart_Cb_Description ***instance_descriptions, unsigned int *instance_count) { - Evas_Object_Smart *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (class_descriptions) *class_descriptions = NULL; if (class_count) *class_count = 0; if (instance_descriptions) *instance_descriptions = NULL; if (instance_count) *instance_count = 0; return; MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + eo_do((Eo *)eo_obj, evas_obj_smart_callbacks_descriptions_get(class_descriptions, class_count, instance_descriptions, instance_count)); +} + +static void +_smart_callbacks_descriptions_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Smart_Cb_Description ***class_descriptions = va_arg(*list, const Evas_Smart_Cb_Description ***); + unsigned int *class_count = va_arg(*list, unsigned int *); + const Evas_Smart_Cb_Description ***instance_descriptions = va_arg(*list, const Evas_Smart_Cb_Description ***); + unsigned int *instance_count = va_arg(*list, unsigned int *); + const Evas_Object_Smart *o = _pd; if (class_descriptions) *class_descriptions = NULL; if (class_count) *class_count = 0; - if (instance_descriptions) *instance_descriptions = NULL; - if (instance_count) *instance_count = 0; - return; - MAGIC_CHECK_END(); - if (class_descriptions) - *class_descriptions = obj->smart.smart->callbacks.array; - if (class_count) + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (obj->smart.smart && class_descriptions) + *class_descriptions = obj->smart.smart->callbacks.array; + if (obj->smart.smart && class_count) *class_count = obj->smart.smart->callbacks.size; if (instance_descriptions) @@ -685,9 +824,22 @@ evas_object_smart_callbacks_descriptions_get(const Evas_Object *obj, const Evas_ } EAPI void -evas_object_smart_callback_description_find(const Evas_Object *obj, const char *name, const Evas_Smart_Cb_Description **class_description, const Evas_Smart_Cb_Description **instance_description) +evas_object_smart_callback_description_find(const Evas_Object *eo_obj, const char *name, const Evas_Smart_Cb_Description **class_description, const Evas_Smart_Cb_Description **instance_description) { - Evas_Object_Smart *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (class_description) *class_description = NULL; + if (instance_description) *instance_description = NULL; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_smart_callback_description_find(name, class_description, instance_description)); +} + +static void +_smart_callback_description_find(Eo *eo_obj, void *_pd, va_list *list) +{ + const char *name = va_arg(*list, const char *); + const Evas_Smart_Cb_Description **class_description = va_arg(*list, const Evas_Smart_Cb_Description **); + const Evas_Smart_Cb_Description **instance_description = va_arg(*list, const Evas_Smart_Cb_Description **); if (!name) { @@ -696,18 +848,8 @@ evas_object_smart_callback_description_find(const Evas_Object *obj, const char * return; } - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (class_description) *class_description = NULL; - if (instance_description) *instance_description = NULL; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - if (class_description) *class_description = NULL; - if (instance_description) *instance_description = NULL; - return; - MAGIC_CHECK_END(); - + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + const Evas_Object_Smart *o = _pd; if (class_description) *class_description = evas_smart_cb_description_find (&obj->smart.smart->callbacks, name); @@ -718,16 +860,20 @@ evas_object_smart_callback_description_find(const Evas_Object *obj, const char * } EAPI void -evas_object_smart_need_recalculate_set(Evas_Object *obj, Eina_Bool value) +evas_object_smart_need_recalculate_set(Evas_Object *eo_obj, Eina_Bool value) { - Evas_Object_Smart *o; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = obj->object_data; - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_smart_need_recalculate_set(value)); +} + +static void +_smart_need_recalculate_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Eina_Bool value = va_arg(*list, int); + Evas_Object_Smart *o = _pd; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); // XXX: do i need this? if (obj->delete_me) return; @@ -754,55 +900,75 @@ evas_object_smart_need_recalculate_set(Evas_Object *obj, Eina_Bool value) } EAPI Eina_Bool -evas_object_smart_need_recalculate_get(const Evas_Object *obj) +evas_object_smart_need_recalculate_get(const Evas_Object *eo_obj) { - Evas_Object_Smart *o; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = obj->object_data; - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return EINA_FALSE; MAGIC_CHECK_END(); + Eina_Bool need_recalculate = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_smart_need_recalculate_get(&need_recalculate)); + return need_recalculate; +} - return o->need_recalculate; +static void +_smart_need_recalculate_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *need_recalculate = va_arg(*list, Eina_Bool *); + const Evas_Object_Smart *o = _pd; + if (need_recalculate) *need_recalculate = o->need_recalculate; } EAPI void -evas_object_smart_calculate(Evas_Object *obj) +evas_object_smart_calculate(Evas_Object *eo_obj) { - Evas_Object_Smart *o; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = obj->object_data; - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_smart_calculate()); +} - if (!obj->smart.smart->smart_class->calculate) +static void +_smart_calculate(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Smart *o = _pd; + + if (!obj->smart.smart || !obj->smart.smart->smart_class->calculate) return; o->need_recalculate = 0; - obj->smart.smart->smart_class->calculate(obj); + obj->smart.smart->smart_class->calculate(eo_obj); } EAPI void -evas_smart_objects_calculate(Evas *e) +evas_smart_objects_calculate(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); - evas_call_smarts_calculate(e); + eo_do(eo_e, evas_canvas_smart_objects_calculate()); +} + +void +_canvas_smart_objects_calculate(Eo *eo_e, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + evas_call_smarts_calculate(eo_e); } EAPI int -evas_smart_objects_calculate_count_get(const Evas *e) +evas_smart_objects_calculate_count_get(const Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return e->smart_calc_count; + int ret = 0; + eo_do((Eo *)eo_e, evas_canvas_smart_objects_calculate_count_get(&ret)); + return ret; +} + +void +_canvas_smart_objects_calculate_count_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int *ret = va_arg(*list, int *); + const Evas_Public_Data *e = _pd; + *ret = e->smart_calc_count; } /** @@ -811,13 +977,14 @@ evas_smart_objects_calculate_count_get(const Evas *e) * @internal */ void -evas_call_smarts_calculate(Evas *e) +evas_call_smarts_calculate(Evas *eo_e) { Eina_Clist *elem; - Evas_Object *obj; + Evas_Object_Protected_Data *obj; + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); // printf("+CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC-----------v\n"); - evas_event_freeze(e); + evas_event_freeze(eo_e); e->in_smart_calc++; while (NULL != (elem = eina_clist_head(&e->calc_list))) @@ -825,52 +992,62 @@ evas_call_smarts_calculate(Evas *e) Evas_Object_Smart *o; /* move the item to the processed list */ - obj = EINA_CLIST_ENTRY(elem, Evas_Object, calc_entry); + obj = EINA_CLIST_ENTRY(elem, Evas_Object_Protected_Data, calc_entry); eina_clist_remove(&obj->calc_entry); if (obj->delete_me) continue; eina_clist_add_tail(&e->calc_done, &obj->calc_entry); - o = obj->object_data; + o = eo_data_get(obj->object, MY_CLASS); if (o->need_recalculate) { o->need_recalculate = 0; - obj->smart.smart->smart_class->calculate(obj); + if (obj->smart.smart && obj->smart.smart->smart_class->calculate) + obj->smart.smart->smart_class->calculate(obj->object); + else + eo_do(obj->object, evas_obj_smart_calculate()); } } while (NULL != (elem = eina_clist_head(&e->calc_done))) { - obj = EINA_CLIST_ENTRY(elem, Evas_Object, calc_entry); + obj = EINA_CLIST_ENTRY(elem, Evas_Object_Protected_Data, calc_entry); obj->recalculate_cycle = 0; eina_clist_remove(&obj->calc_entry); } e->in_smart_calc--; if (e->in_smart_calc == 0) e->smart_calc_count++; - evas_event_thaw(e); - evas_event_thaw_eval(e); + evas_event_thaw(eo_e); + evas_event_thaw_eval(eo_e); } EAPI void -evas_object_smart_changed(Evas_Object *obj) +evas_object_smart_changed(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - evas_object_change(obj); - evas_object_smart_need_recalculate_set(obj, 1); + eo_do(eo_obj, evas_obj_smart_changed()); +} + +static void +_smart_changed(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); + eo_do(eo_obj, evas_obj_smart_need_recalculate_set(1)); } /* internal calls */ static void -evas_object_smart_callbacks_clear(Evas_Object *obj) +evas_object_smart_callbacks_clear(Evas_Object *eo_obj) { Evas_Object_Smart *o; Eina_List *l; Evas_Smart_Callback *cb; - o = (Evas_Object_Smart *)(obj->object_data); + o = eo_data_get(eo_obj, MY_CLASS); if (o->walking_list) return; if (!o->deletions_waiting) return; @@ -888,23 +1065,29 @@ evas_object_smart_callbacks_clear(Evas_Object *obj) } void -evas_object_smart_del(Evas_Object *obj) +evas_object_smart_del(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); Evas_Smart *s; unsigned int i; if (obj->delete_me) return; s = obj->smart.smart; + if (s && s->smart_class->del) + s->smart_class->del(eo_obj); + else + eo_do(eo_obj, evas_obj_smart_del()); + if (obj->smart.parent) evas_object_smart_member_del(eo_obj); - if ((s) && (s->smart_class->del)) s->smart_class->del(obj); - if (obj->smart.parent) evas_object_smart_member_del(obj); - - for (i = 0; i < s->interfaces.size; i++) + if (s) { - const Evas_Smart_Interface *iface; + for (i = 0; i < s->interfaces.size; i++) + { + const Evas_Smart_Interface *iface; - iface = s->interfaces.array[i]; - if (iface->del) iface->del(obj); + iface = s->interfaces.array[i]; + if (iface->del) iface->del(eo_obj); + } } free(obj->interface_privates); @@ -914,21 +1097,24 @@ evas_object_smart_del(Evas_Object *obj) } void -evas_object_smart_cleanup(Evas_Object *obj) +evas_object_smart_cleanup(Evas_Object *eo_obj) { - Evas_Object_Smart *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (obj->smart.parent) - evas_object_smart_member_del(obj); + evas_object_smart_member_del(eo_obj); - o = (Evas_Object_Smart *)(obj->object_data); - if (o->magic == MAGIC_OBJ_SMART) + if (obj->is_smart) { + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); if (obj->calc_entry.next) eina_clist_remove(&obj->calc_entry); while (o->contained) - evas_object_smart_member_del((Evas_Object *)o->contained); + { + Evas_Object *contained_obj = ((Evas_Object_Protected_Data *)o->contained)->object; + evas_object_smart_member_del(contained_obj); + } while (o->callbacks) { @@ -947,75 +1133,81 @@ evas_object_smart_cleanup(Evas_Object *obj) } void -evas_object_smart_member_cache_invalidate(Evas_Object *obj, +evas_object_smart_member_cache_invalidate(Evas_Object *eo_obj, Eina_Bool pass_events, Eina_Bool freeze_events) { - Evas_Object_Smart *o; - Evas_Object *member; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Protected_Data *member; + if (pass_events) obj->parent_cache.pass_events_valid = EINA_FALSE; if (freeze_events) obj->parent_cache.freeze_events_valid = EINA_FALSE; - o = obj->object_data; - if (o->magic != MAGIC_OBJ_SMART) return; - + if (!obj->is_smart) return; + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); EINA_INLIST_FOREACH(o->contained, member) - evas_object_smart_member_cache_invalidate(member, + { + Evas_Object *eo_member = member->object; + evas_object_smart_member_cache_invalidate(eo_member, pass_events, freeze_events); + } } void -evas_object_smart_member_raise(Evas_Object *member) +evas_object_smart_member_raise(Evas_Object *eo_member) { Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(member->smart.parent->object_data); + Evas_Object_Protected_Data *member = eo_data_get(eo_member, EVAS_OBJ_CLASS); + o = eo_data_get(member->smart.parent, MY_CLASS); o->contained = eina_inlist_demote(o->contained, EINA_INLIST_GET(member)); } void -evas_object_smart_member_lower(Evas_Object *member) +evas_object_smart_member_lower(Evas_Object *eo_member) { Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(member->smart.parent->object_data); + Evas_Object_Protected_Data *member = eo_data_get(eo_member, EVAS_OBJ_CLASS); + o = eo_data_get(member->smart.parent, MY_CLASS); o->contained = eina_inlist_promote(o->contained, EINA_INLIST_GET(member)); } void -evas_object_smart_member_stack_above(Evas_Object *member, Evas_Object *other) +evas_object_smart_member_stack_above(Evas_Object *eo_member, Evas_Object *eo_other) { Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(member->smart.parent->object_data); + Evas_Object_Protected_Data *member = eo_data_get(eo_member, EVAS_OBJ_CLASS); + Evas_Object_Protected_Data *other = eo_data_get(eo_other, EVAS_OBJ_CLASS); + o = eo_data_get(member->smart.parent, MY_CLASS); o->contained = eina_inlist_remove(o->contained, EINA_INLIST_GET(member)); o->contained = eina_inlist_append_relative(o->contained, EINA_INLIST_GET(member), EINA_INLIST_GET(other)); } void -evas_object_smart_member_stack_below(Evas_Object *member, Evas_Object *other) +evas_object_smart_member_stack_below(Evas_Object *eo_member, Evas_Object *eo_other) { Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(member->smart.parent->object_data); + Evas_Object_Protected_Data *member = eo_data_get(eo_member, EVAS_OBJ_CLASS); + Evas_Object_Protected_Data *other = eo_data_get(eo_other, EVAS_OBJ_CLASS); + o = eo_data_get(member->smart.parent, MY_CLASS); o->contained = eina_inlist_remove(o->contained, EINA_INLIST_GET(member)); o->contained = eina_inlist_prepend_relative(o->contained, EINA_INLIST_GET(member), EINA_INLIST_GET(other)); } void -evas_object_smart_need_bounding_box_update(Evas_Object *obj) +evas_object_smart_need_bounding_box_update(Evas_Object *eo_obj) { - Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(obj->object_data); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); if (o->update_boundingbox_needed) return ; o->update_boundingbox_needed = EINA_TRUE; @@ -1024,17 +1216,20 @@ evas_object_smart_need_bounding_box_update(Evas_Object *obj) } void -evas_object_smart_bouding_box_update(Evas_Object *obj) +evas_object_smart_bouding_box_update(Evas_Object *eo_obj) { Eina_Inlist *list; - Evas_Object *o; - Evas_Object_Smart *os; + Evas_Object_Protected_Data *o; Evas_Coord minx; Evas_Coord miny; Evas_Coord maxw = 0; Evas_Coord maxh = 0; - os = (Evas_Object_Smart *)(obj->object_data); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Smart *os = eo_data_get(eo_obj, MY_CLASS); if (!os->update_boundingbox_needed) return ; os->update_boundingbox_needed = EINA_FALSE; @@ -1053,9 +1248,9 @@ evas_object_smart_bouding_box_update(Evas_Object *obj) if (o == obj) continue ; if (o->clip.clipees || o->is_static_clip) continue ; - if (o->smart.smart) + if (eo_isa(o->object, EVAS_OBJ_SMART_CLASS)) { - evas_object_smart_bouding_box_update(o); + evas_object_smart_bouding_box_update(o->object); tx = o->cur.bounding_box.x; ty = o->cur.bounding_box.y; @@ -1101,10 +1296,10 @@ evas_object_smart_bouding_box_update(Evas_Object *obj) /* all nice and private */ static void -evas_object_smart_init(Evas_Object *obj) +evas_object_smart_init(Evas_Object *eo_obj) { - /* alloc smart obj, setup methods and default values */ - obj->object_data = evas_object_smart_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + obj->is_smart = EINA_TRUE; /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -1121,45 +1316,16 @@ evas_object_smart_init(Evas_Object *obj) obj->func = &object_func; } -static void * -evas_object_smart_new(void) -{ - Evas_Object_Smart *o; - - /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_smart", Evas_Object_Smart, 32, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Smart); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Smart); - o->magic = MAGIC_OBJ_SMART; - return o; -} - static void -evas_object_smart_free(Evas_Object *obj) -{ - Evas_Object_Smart *o; - - /* frees private object data. very simple here */ - o = (Evas_Object_Smart *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Smart, MAGIC_OBJ_SMART); - return; - MAGIC_CHECK_END(); - /* free obj */ - o->magic = 0; - EVAS_MEMPOOL_FREE(_mp_obj, o); -} - -static void -evas_object_smart_render(Evas_Object *obj __UNUSED__, void *output __UNUSED__, void *context __UNUSED__, void *surface __UNUSED__, int x __UNUSED__, int y __UNUSED__) +evas_object_smart_render(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED, void *output EINA_UNUSED, void *context EINA_UNUSED, void *surface EINA_UNUSED, int x EINA_UNUSED, int y EINA_UNUSED) { return; } static void -evas_object_smart_render_pre(Evas_Object *obj) +evas_object_smart_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas *e; + Evas_Public_Data *e; if (obj->pre_render_done) return; if (!obj->child_has_map && !obj->cur.cached_surface) @@ -1210,7 +1376,7 @@ evas_object_smart_render_pre(Evas_Object *obj) /* speed_py = obj->smart.parent->cur.bounding_box.y - obj->smart.parent->prev.bounding_box.y; */ fprintf(stderr, "speed: '%s',%p (%i, %i) vs '%s',%p (%i, %i)\n", - evas_object_type_get(obj), obj, speed_x, speed_y, + evas_object_type_get(eo_obj), obj, speed_x, speed_y, evas_object_type_get(obj->smart.parent), obj->smart.parent, speed_px, speed_py); if (speed_x != speed_px || speed_y != speed_py) @@ -1220,7 +1386,7 @@ evas_object_smart_render_pre(Evas_Object *obj) if (cache_map) fprintf(stderr, "Wouhou, I can detect moving smart object (%s, %p [%i, %i, %i, %i] < %s, %p [%i, %i, %i, %i])\n", - evas_object_type_get(obj), obj, + evas_object_type_get(eo_obj), obj, obj->cur.bounding_box.x - obj->prev.bounding_box.x, obj->cur.bounding_box.y - obj->prev.bounding_box.y, obj->cur.bounding_box.w, obj->cur.bounding_box.h, @@ -1238,41 +1404,110 @@ evas_object_smart_render_pre(Evas_Object *obj) if (obj->changed_map) { - evas_object_render_pre_prev_cur_add(&e->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&e->clip_changes, eo_obj, obj); } obj->pre_render_done = EINA_TRUE; } static void -evas_object_smart_render_post(Evas_Object *obj) +evas_object_smart_render_post(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); } -static unsigned int evas_object_smart_id_get(Evas_Object *obj) +static unsigned int evas_object_smart_id_get(Evas_Object *eo_obj) { - Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(obj->object_data); + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_SMART; } -static unsigned int evas_object_smart_visual_id_get(Evas_Object *obj) +static unsigned int evas_object_smart_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(obj->object_data); + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_CONTAINER; } -static void *evas_object_smart_engine_data_get(Evas_Object *obj) +static void *evas_object_smart_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Smart *o; - - o = (Evas_Object_Smart *)(obj->object_data); + Evas_Object_Smart *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return NULL; return o->engine_data; } + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_CHECK), _type_check), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DATA_SET), _smart_data_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SMART_GET), _smart_smart_get), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBER_ADD), _smart_member_add), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBER_DEL), _smart_member_del), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBERS_GET), _smart_members_get), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_SET), _smart_callbacks_descriptions_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_GET), _smart_callbacks_descriptions_get), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALLBACK_DESCRIPTION_FIND), _smart_callback_description_find), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_SET), _smart_need_recalculate_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_GET), _smart_need_recalculate_get), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALCULATE), _smart_calculate), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CHANGED), _smart_changed), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_SMART_DATA_GET), _smart_data_get), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ATTACH), _smart_attach), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _smart_add), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _smart_del), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _smart_resize), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), _smart_move), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SHOW), _smart_show), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_HIDE), _smart_hide), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_COLOR_SET), _smart_color_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CLIP_SET), _smart_clip_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CLIP_UNSET), _smart_clip_unset), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_DATA_SET, "Store a pointer to user data for a given smart object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_SMART_GET, "Get the #Evas_Smart from which obj smart object was created."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_MEMBER_ADD, "Set an Evas object as a member of a given smart object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_MEMBER_DEL, "Removes a member object from a given smart object."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_MEMBERS_GET, "Retrieves the list of the member objects of a given Evas smart"), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_SET, "Set an smart object instance's smart callbacks descriptions."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CALLBACKS_DESCRIPTIONS_GET, "Retrieve an smart object's know smart callback descriptions (both"), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CALLBACK_DESCRIPTION_FIND, "Find callback description for callback called name."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_SET, "Set or unset the flag signalling that a given smart object needs to"), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_NEED_RECALCULATE_GET, "Get the value of the flag signalling that a given smart object needs to"), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CALCULATE, "Call the calculate() smart function immediately on a given smart"), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CHANGED, "Mark smart object as changed, dirty."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_ATTACH, "Attach an object to a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_ADD, "Add an object to a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_DEL, "Remove an object from a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_RESIZE, "Resize an object on a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_MOVE, "Move an object on a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_SHOW, "Show an object on a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_HIDE, "Hide an object on a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_COLOR_SET, "Set color of an object on a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CLIP_SET, "Set a clipper of an object on a canvas."), + EO_OP_DESCRIPTION(EVAS_OBJ_SMART_SUB_ID_CLIP_UNSET, "Unset a clipper of an object on a canvas."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + MY_CLASS_NAME, + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_SMART_BASE_ID, op_desc, EVAS_OBJ_SMART_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Smart), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_smart_class_get, &class_desc, EVAS_OBJ_CLASS, EVAS_SMART_SIGNAL_INTERFACE, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_smart_clipped.c b/legacy/evas/src/lib/canvas/evas_object_smart_clipped.c index 648c0fab26..3263b751e8 100644 --- a/legacy/evas/src/lib/canvas/evas_object_smart_clipped.c +++ b/legacy/evas/src/lib/canvas/evas_object_smart_clipped.c @@ -1,20 +1,38 @@ #include "evas_common.h" #include "evas_private.h" -#define CSO_DATA_GET_OR_RETURN(obj, ptr) \ - Evas_Object_Smart_Clipped_Data *ptr = evas_object_smart_data_get(obj); \ +EAPI Eo_Op EVAS_OBJ_SMART_CLIPPED_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_SMART_CLIPPED_CLASS + +#define CSO_DATA_GET(eo_obj, ptr) \ + Evas_Object_Smart_Clipped_Data *ptr = (eo_isa(eo_obj, MY_CLASS) ? \ + eo_data_get(eo_obj, MY_CLASS) : \ + evas_object_smart_data_get(eo_obj)); + +#define CSO_DATA_GET_OR_RETURN(eo_obj, ptr) \ + CSO_DATA_GET(eo_obj, ptr) \ if (!ptr) return; EAPI void -evas_object_smart_move_children_relative(Evas_Object *obj, Evas_Coord dx, Evas_Coord dy) +evas_object_smart_move_children_relative(Evas_Object *eo_obj, Evas_Coord dx, Evas_Coord dy) { + eo_do(eo_obj, evas_obj_smart_move_children_relative(dx, dy)); +} + +void +_smart_move_children_relative(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Coord dx = va_arg(*list, Evas_Coord); + Evas_Coord dy = va_arg(*list, Evas_Coord); + const Eina_Inlist *lst; - Evas_Object *child; + Evas_Object_Protected_Data *child; if ((dx == 0) && (dy == 0)) return; - lst = evas_object_smart_members_get_direct(obj); + lst = evas_object_smart_members_get_direct(eo_obj); EINA_INLIST_FOREACH(lst, child) { Evas_Coord orig_x, orig_y; @@ -25,35 +43,43 @@ evas_object_smart_move_children_relative(Evas_Object *obj, Evas_Coord dx, Evas_C if (child->is_static_clip) continue; orig_x = child->cur.geometry.x; orig_y = child->cur.geometry.y; - evas_object_move(child, orig_x + dx, orig_y + dy); + evas_object_move(child->object, orig_x + dx, orig_y + dy); } } EAPI Evas_Object * -evas_object_smart_clipped_clipper_get(Evas_Object *obj) +evas_object_smart_clipped_clipper_get(Evas_Object *eo_obj) { - Evas_Object_Smart_Clipped_Data *cso = evas_object_smart_data_get(obj); - if (!cso) - return NULL; + Evas_Object *ret = NULL; + eo_do((Eo *)eo_obj, evas_obj_smart_clipped_clipper_get(&ret)); + return ret; +} - return cso->clipper; +void +_smart_clipped_clipper_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object **ret = va_arg(*list, Evas_Object **); + CSO_DATA_GET(eo_obj, cso) + if (!cso) + *ret = NULL; + else + *ret = cso->clipper; } static void -evas_object_smart_clipped_smart_add(Evas_Object *obj) +evas_object_smart_clipped_smart_add(Evas_Object *eo_obj) { - Evas_Object_Smart_Clipped_Data *cso; Evas_Object *clipper; - cso = evas_object_smart_data_get(obj); + CSO_DATA_GET(eo_obj, cso) if (!cso) cso = calloc(1, sizeof(*cso)); /* users can provide it or realloc() later */ - cso->evas = evas_object_evas_get(obj); + cso->evas = evas_object_evas_get(eo_obj); clipper = evas_object_rectangle_add(cso->evas); evas_object_static_clip_set(clipper, 1); cso->clipper = NULL; - evas_object_smart_member_add(clipper, obj); + evas_object_smart_member_add(clipper, eo_obj); cso->clipper = clipper; evas_object_color_set(cso->clipper, 255, 255, 255, 255); evas_object_move(cso->clipper, -100000, -100000); @@ -61,13 +87,19 @@ evas_object_smart_clipped_smart_add(Evas_Object *obj) evas_object_pass_events_set(cso->clipper, 1); evas_object_hide(cso->clipper); /* show when have something clipped to it */ - evas_object_smart_data_set(obj, cso); + evas_object_smart_data_set(eo_obj, cso); } static void -evas_object_smart_clipped_smart_del(Evas_Object *obj) +_smart_add(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - CSO_DATA_GET_OR_RETURN(obj, cso); + evas_object_smart_clipped_smart_add(eo_obj); +} + +static void +evas_object_smart_clipped_smart_del(Evas_Object *eo_obj) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); if (cso->clipper) { @@ -76,72 +108,128 @@ evas_object_smart_clipped_smart_del(Evas_Object *obj) evas_object_del(clipper); } - _evas_object_smart_members_all_del(obj); + _evas_object_smart_members_all_del(eo_obj); - free(cso); - evas_object_smart_data_set(obj, NULL); + evas_object_smart_data_set(eo_obj, NULL); } static void -evas_object_smart_clipped_smart_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y) +_smart_del(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + evas_object_smart_clipped_smart_del(eo_obj); +} + +static void +evas_object_smart_clipped_smart_move(Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y) { Evas_Coord orig_x, orig_y; - evas_object_geometry_get(obj, &orig_x, &orig_y, NULL, NULL); - evas_object_smart_move_children_relative(obj, x - orig_x, y - orig_y); + evas_object_geometry_get(eo_obj, &orig_x, &orig_y, NULL, NULL); + evas_object_smart_move_children_relative(eo_obj, x - orig_x, y - orig_y); } static void -evas_object_smart_clipped_smart_show(Evas_Object *obj) +_smart_move(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) { - CSO_DATA_GET_OR_RETURN(obj, cso); + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + evas_object_smart_clipped_smart_move(eo_obj, x, y); +} + +static void +evas_object_smart_clipped_smart_show(Evas_Object *eo_obj) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); if (evas_object_clipees_get(cso->clipper)) evas_object_show(cso->clipper); /* just show if clipper being used */ } static void -evas_object_smart_clipped_smart_hide(Evas_Object *obj) +_smart_show(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - CSO_DATA_GET_OR_RETURN(obj, cso); + evas_object_smart_clipped_smart_show(eo_obj); +} + +static void +evas_object_smart_clipped_smart_hide(Evas_Object *eo_obj) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); evas_object_hide(cso->clipper); } static void -evas_object_smart_clipped_smart_color_set(Evas_Object *obj, int r, int g, int b, int a) +_smart_hide(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - CSO_DATA_GET_OR_RETURN(obj, cso); + evas_object_smart_clipped_smart_hide(eo_obj); +} + +static void +evas_object_smart_clipped_smart_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); evas_object_color_set(cso->clipper, r, g, b, a); } static void -evas_object_smart_clipped_smart_clip_set(Evas_Object *obj, Evas_Object *clip) +_smart_color_set(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) { - CSO_DATA_GET_OR_RETURN(obj, cso); + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + evas_object_smart_clipped_smart_color_set(eo_obj, r, g, b, a); +} + +static void +evas_object_smart_clipped_smart_clip_set(Evas_Object *eo_obj, Evas_Object *clip) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); evas_object_clip_set(cso->clipper, clip); } static void -evas_object_smart_clipped_smart_clip_unset(Evas_Object *obj) +_smart_clip_set(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) { - CSO_DATA_GET_OR_RETURN(obj, cso); + Evas_Object *clip = va_arg(*list, Evas_Object *); + evas_object_smart_clipped_smart_clip_set(eo_obj, clip); +} + +static void +evas_object_smart_clipped_smart_clip_unset(Evas_Object *eo_obj) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); evas_object_clip_unset(cso->clipper); } static void -evas_object_smart_clipped_smart_member_add(Evas_Object *obj, Evas_Object *member) +_smart_clip_unset(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - CSO_DATA_GET_OR_RETURN(obj, cso); + evas_object_smart_clipped_smart_clip_unset(eo_obj); +} + +static void +evas_object_smart_clipped_smart_member_add(Evas_Object *eo_obj, Evas_Object *member) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); if (!cso->clipper || member == cso->clipper) return; evas_object_clip_set(member, cso->clipper); - if (evas_object_visible_get(obj)) + if (evas_object_visible_get(eo_obj)) evas_object_show(cso->clipper); } static void -evas_object_smart_clipped_smart_member_del(Evas_Object *obj, Evas_Object *member) +_smart_member_add(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) { - CSO_DATA_GET_OR_RETURN(obj, cso); + Evas_Object *member = va_arg(*list, Evas_Object *); + eo_do_super(eo_obj, evas_obj_smart_member_add(member)); + evas_object_smart_clipped_smart_member_add(eo_obj, member); +} + +static void +evas_object_smart_clipped_smart_member_del(Evas_Object *eo_obj, Evas_Object *member) +{ + CSO_DATA_GET_OR_RETURN(eo_obj, cso); if (!cso->clipper) return; evas_object_clip_unset(member); @@ -149,6 +237,14 @@ evas_object_smart_clipped_smart_member_del(Evas_Object *obj, Evas_Object *member evas_object_hide(cso->clipper); } +static void +_smart_member_del(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object *member = va_arg(*list, Evas_Object *); + evas_object_smart_clipped_smart_member_del(eo_obj, member); + eo_do_super(eo_obj, evas_obj_smart_member_del(member)); +} + EAPI void evas_object_smart_clipped_smart_set(Evas_Smart_Class *sc) { @@ -181,3 +277,60 @@ evas_object_smart_clipped_class_get(void) class = &_sc; return class; } + +static void +_type_check(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + const char *type = va_arg(*list, const char *); + Eina_Bool *type_check = va_arg(*list, Eina_Bool *); + if (0 == strcmp(type, "EvasObjectSmartClipped")) + *type_check = EINA_TRUE; + else + eo_do_super(eo_obj, evas_obj_type_check(type, type_check)); +} + +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); +} + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EVAS_OBJ_ID(EVAS_OBJ_SUB_ID_TYPE_CHECK), _type_check), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _smart_add), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _smart_del), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), _smart_move), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SHOW), _smart_show), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_HIDE), _smart_hide), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_COLOR_SET), _smart_color_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CLIP_SET), _smart_clip_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CLIP_UNSET), _smart_clip_unset), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBER_ADD), _smart_member_add), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MEMBER_DEL), _smart_member_del), + EO_OP_FUNC_SENTINEL + }; + + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Smart_Clipped", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_SMART_CLIPPED_BASE_ID, op_desc, EVAS_OBJ_SMART_CLIPPED_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Smart_Clipped_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_smart_clipped_eo_class_get, &class_desc, EVAS_OBJ_SMART_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_table.c b/legacy/evas/src/lib/canvas/evas_object_table.c index abec3af403..da5550d847 100644 --- a/legacy/evas/src/lib/canvas/evas_object_table.c +++ b/legacy/evas/src/lib/canvas/evas_object_table.c @@ -1,6 +1,15 @@ #include "evas_common.h" +#include "evas_private.h" #include +#include + +EAPI Eo_Op EVAS_OBJ_TABLE_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_TABLE_CLASS + +#define MY_CLASS_NAME "Evas_Object_Table" + typedef struct _Evas_Object_Table_Data Evas_Object_Table_Data; typedef struct _Evas_Object_Table_Option Evas_Object_Table_Option; typedef struct _Evas_Object_Table_Cache Evas_Object_Table_Cache; @@ -53,7 +62,6 @@ struct _Evas_Object_Table_Cache struct _Evas_Object_Table_Data { - Evas_Object_Smart_Clipped_Data base; Eina_List *children; struct { Evas_Coord h, v; @@ -89,7 +97,7 @@ struct _Evas_Object_Table_Accessor }; #define EVAS_OBJECT_TABLE_DATA_GET(o, ptr) \ - Evas_Object_Table_Data *ptr = evas_object_smart_data_get(o) + Evas_Object_Table_Data *ptr = eo_data_get(o, MY_CLASS) #define EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(o, ptr) \ EVAS_OBJECT_TABLE_DATA_GET(o, ptr); \ @@ -867,15 +875,10 @@ _evas_object_table_smart_calculate_regular(Evas_Object *o, Evas_Object_Table_Dat _evas_object_table_calculate_layout_regular(o, priv); } -EVAS_SMART_SUBCLASS_NEW("Evas_Object_Table", _evas_object_table, - Evas_Smart_Class, Evas_Smart_Class, - evas_object_smart_clipped_class_get, NULL) - static void -_evas_object_table_smart_add(Evas_Object *o) +_smart_add(Eo *obj, void *_pd, va_list *list EINA_UNUSED) { - EVAS_SMART_DATA_ALLOC(o, Evas_Object_Table_Data) - + Evas_Object_Table_Data *priv = _pd; priv->pad.h = 0; priv->pad.v = 0; priv->align.h = 0.5; @@ -888,20 +891,20 @@ _evas_object_table_smart_add(Evas_Object *o) priv->expand_h = 0; priv->expand_v = 0; - _evas_object_table_parent_sc->add(o); + eo_do_super(obj, evas_obj_smart_add()); } static void -_evas_object_table_smart_del(Evas_Object *o) +_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED) { - EVAS_OBJECT_TABLE_DATA_GET(o, priv); + Evas_Object_Table_Data *priv = _pd; Eina_List *l; l = priv->children; while (l) { Evas_Object_Table_Option *opt = l->data; - _evas_object_table_child_disconnect(o, opt->obj); + _evas_object_table_child_disconnect(obj, opt->obj); _evas_object_table_option_del(opt->obj); free(opt); l = eina_list_remove_list(l, l); @@ -913,22 +916,24 @@ _evas_object_table_smart_del(Evas_Object *o) priv->cache = NULL; } - _evas_object_table_parent_sc->del(o); + eo_do_super(obj, evas_obj_smart_del()); } static void -_evas_object_table_smart_resize(Evas_Object *o, Evas_Coord w, Evas_Coord h) +_smart_resize(Eo *obj, void *_pd EINA_UNUSED, va_list *list) { + Evas_Coord w = va_arg(*list, Evas_Coord); + Evas_Coord h = va_arg(*list, Evas_Coord); Evas_Coord ow, oh; - evas_object_geometry_get(o, NULL, NULL, &ow, &oh); + evas_object_geometry_get(obj, NULL, NULL, &ow, &oh); if ((ow == w) && (oh == h)) return; - evas_object_smart_changed(o); + evas_object_smart_changed(obj); } static void -_evas_object_table_smart_calculate(Evas_Object *o) +_smart_calculate(Eo *o, void *_pd, va_list *list EINA_UNUSED) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(o, priv); + Evas_Object_Table_Data *priv = _pd; if ((priv->size.cols < 1) || (priv->size.rows < 1)) { @@ -943,37 +948,52 @@ _evas_object_table_smart_calculate(Evas_Object *o) _evas_object_table_smart_calculate_regular(o, priv); } -static void -_evas_object_table_smart_set_user(Evas_Smart_Class *sc) -{ - sc->add = _evas_object_table_smart_add; - sc->del = _evas_object_table_smart_del; - sc->resize = _evas_object_table_smart_resize; - sc->calculate = _evas_object_table_smart_calculate; -} - EAPI Evas_Object * evas_object_table_add(Evas *evas) { - return evas_object_smart_add(evas, _evas_object_table_smart_class_new()); + Evas_Object *obj = eo_add(MY_CLASS, evas); + eo_unref(obj); + return obj; +} + +static void +_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(obj, eo_constructor()); + eo_do(obj, evas_obj_type_set(MY_CLASS_NAME)); } EAPI Evas_Object * evas_object_table_add_to(Evas_Object *parent) { + Evas_Object *ret = NULL; + eo_do(parent, evas_obj_table_add_to(&ret)); + return ret; +} + +static void +_add_to(Eo *parent, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object **ret = va_arg(*list, Evas_Object **); Evas *evas; - Evas_Object *o; evas = evas_object_evas_get(parent); - o = evas_object_table_add(evas); - evas_object_smart_member_add(o, parent); - return o; + *ret = evas_object_table_add(evas); + evas_object_smart_member_add(*ret, parent); } EAPI void evas_object_table_homogeneous_set(Evas_Object *o, Evas_Object_Table_Homogeneous_Mode homogeneous) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_table_homogeneous_set(homogeneous)); +} + +static void +_homogeneous_set(Eo *o, void *_pd, va_list *list) +{ + Evas_Object_Table_Homogeneous_Mode homogeneous = va_arg(*list, Evas_Object_Table_Homogeneous_Mode); + + Evas_Object_Table_Data *priv = _pd; if (priv->homogeneous == homogeneous) return; priv->homogeneous = homogeneous; @@ -984,14 +1004,32 @@ evas_object_table_homogeneous_set(Evas_Object *o, Evas_Object_Table_Homogeneous_ EAPI Evas_Object_Table_Homogeneous_Mode evas_object_table_homogeneous_get(const Evas_Object *o) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, 0); - return priv->homogeneous; + Evas_Object_Table_Homogeneous_Mode ret = EVAS_OBJECT_TABLE_HOMOGENEOUS_NONE; + eo_do((Eo *)o, evas_obj_table_homogeneous_get(&ret)); + return ret; +} + +static void +_homogeneous_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Table_Homogeneous_Mode *ret = va_arg(*list, Evas_Object_Table_Homogeneous_Mode *); + const Evas_Object_Table_Data *priv = _pd; + *ret = priv->homogeneous; } EAPI void evas_object_table_align_set(Evas_Object *o, double horizontal, double vertical) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_table_align_set(horizontal, vertical)); +} + +static void +_align_set(Eo *o, void *_pd, va_list *list) +{ + double horizontal = va_arg(*list, double); + double vertical = va_arg(*list, double); + + Evas_Object_Table_Data *priv = _pd; if (priv->align.h == horizontal && priv->align.v == vertical) return; priv->align.h = horizontal; @@ -1002,7 +1040,16 @@ evas_object_table_align_set(Evas_Object *o, double horizontal, double vertical) EAPI void evas_object_table_align_get(const Evas_Object *o, double *horizontal, double *vertical) { - EVAS_OBJECT_TABLE_DATA_GET(o, priv); + eo_do((Eo *)o, evas_obj_table_align_get(horizontal, vertical)); +} + +static void +_align_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + double *horizontal = va_arg(*list, double *); + double *vertical = va_arg(*list, double *); + + const Evas_Object_Table_Data *priv = _pd; if (priv) { if (horizontal) *horizontal = priv->align.h; @@ -1018,7 +1065,16 @@ evas_object_table_align_get(const Evas_Object *o, double *horizontal, double *ve EAPI void evas_object_table_padding_set(Evas_Object *o, Evas_Coord horizontal, Evas_Coord vertical) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(o, priv); + eo_do(o, evas_obj_table_padding_set(horizontal, vertical)); +} + +static void +_padding_set(Eo *o, void *_pd, va_list *list) +{ + Evas_Coord horizontal = va_arg(*list, Evas_Coord); + Evas_Coord vertical = va_arg(*list, Evas_Coord); + + Evas_Object_Table_Data *priv = _pd; if (priv->pad.h == horizontal && priv->pad.v == vertical) return; priv->pad.h = horizontal; @@ -1030,7 +1086,16 @@ evas_object_table_padding_set(Evas_Object *o, Evas_Coord horizontal, Evas_Coord EAPI void evas_object_table_padding_get(const Evas_Object *o, Evas_Coord *horizontal, Evas_Coord *vertical) { - EVAS_OBJECT_TABLE_DATA_GET(o, priv); + eo_do((Eo *)o, evas_obj_table_padding_get(horizontal, vertical)); +} + +static void +_padding_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *horizontal = va_arg(*list, Evas_Coord *); + Evas_Coord *vertical = va_arg(*list, Evas_Coord *); + + const Evas_Object_Table_Data *priv = _pd; if (priv) { if (horizontal) *horizontal = priv->pad.h; @@ -1046,9 +1111,24 @@ evas_object_table_padding_get(const Evas_Object *o, Evas_Coord *horizontal, Evas EAPI Eina_Bool evas_object_table_pack_get(const Evas_Object *o, Evas_Object *child, unsigned short *col, unsigned short *row, unsigned short *colspan, unsigned short *rowspan) { + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)o, evas_obj_table_pack_get(child, col, row, colspan, rowspan, &ret)); + return ret; +} + +static void +_pack_get(Eo *o EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Object *child = va_arg(*list, Evas_Object *); + unsigned short *col = va_arg(*list, unsigned short *); + unsigned short *row = va_arg(*list, unsigned short *); + unsigned short *colspan = va_arg(*list, unsigned short *); + unsigned short *rowspan = va_arg(*list, unsigned short *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; + Evas_Object_Table_Option *opt; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, 0); opt = _evas_object_table_option_get(child); if (!opt) { @@ -1056,31 +1136,47 @@ evas_object_table_pack_get(const Evas_Object *o, Evas_Object *child, unsigned sh if (row) *row = 0; if (colspan) *colspan = 0; if (rowspan) *rowspan = 0; - return EINA_FALSE; + return; } if (col) *col = opt->col; if (row) *row = opt->row; if (colspan) *colspan = opt->colspan; if (rowspan) *rowspan = opt->rowspan; - return EINA_TRUE; + if (ret) *ret = EINA_TRUE; } EAPI Eina_Bool evas_object_table_pack(Evas_Object *o, Evas_Object *child, unsigned short col, unsigned short row, unsigned short colspan, unsigned short rowspan) { + Eina_Bool ret = EINA_FALSE; + eo_do(o, evas_obj_table_pack(child, col, row, colspan, rowspan, &ret)); + return ret; +} + +static void +_pack(Eo *o, void *_pd, va_list *list) +{ + Evas_Object *child = va_arg(*list, Evas_Object *); + unsigned short col = va_arg(*list, int); + unsigned short row = va_arg(*list, int); + unsigned short colspan = va_arg(*list, int); + unsigned short rowspan = va_arg(*list, int); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; + Evas_Object_Table_Option *opt; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, 0); + Evas_Object_Table_Data *priv = _pd; if (rowspan < 1) { ERR("rowspan < 1"); - return EINA_FALSE; + return; } if (colspan < 1) { ERR("colspan < 1"); - return EINA_FALSE; + return; } opt = _evas_object_table_option_get(child); @@ -1090,7 +1186,7 @@ evas_object_table_pack(Evas_Object *o, Evas_Object *child, unsigned short col, u if (!opt) { ERR("could not allocate table option data."); - return EINA_FALSE; + return; } } @@ -1158,7 +1254,7 @@ evas_object_table_pack(Evas_Object *o, Evas_Object *child, unsigned short col, u } _evas_object_table_cache_invalidate(priv); evas_object_smart_changed(o); - return EINA_TRUE; + if (ret) *ret = EINA_TRUE; } static void @@ -1210,21 +1306,33 @@ _evas_object_table_remove_opt(Evas_Object_Table_Data *priv, Evas_Object_Table_Op EAPI Eina_Bool evas_object_table_unpack(Evas_Object *o, Evas_Object *child) { + Eina_Bool ret = EINA_FALSE; + eo_do(o, evas_obj_table_unpack(child, &ret)); + return ret; +} + +static void +_unpack(Eo *o, void *_pd, va_list *list) +{ + Evas_Object *child = va_arg(*list, Evas_Object *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; + Evas_Object_Table_Option *opt; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, 0); + Evas_Object_Table_Data *priv = _pd; if (o != evas_object_smart_parent_get(child)) { ERR("cannot unpack child from incorrect table!"); - return EINA_FALSE; + return; } opt = _evas_object_table_option_del(child); if (!opt) { ERR("cannot unpack child with no packing option!"); - return EINA_FALSE; + return; } _evas_object_table_child_disconnect(o, child); @@ -1234,15 +1342,23 @@ evas_object_table_unpack(Evas_Object *o, Evas_Object *child) _evas_object_table_cache_invalidate(priv); evas_object_smart_changed(o); - return EINA_TRUE; + if (ret) *ret = EINA_TRUE; } EAPI void evas_object_table_clear(Evas_Object *o, Eina_Bool clear) { + eo_do(o, evas_obj_table_clear(clear)); +} + +static void +_clear(Eo *o, void *_pd, va_list *list) +{ + Eina_Bool clear = va_arg(*list, int); + Evas_Object_Table_Option *opt; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(o, priv); + Evas_Object_Table_Data *priv = _pd; EINA_LIST_FREE(priv->children, opt) { @@ -1262,7 +1378,16 @@ evas_object_table_clear(Evas_Object *o, Eina_Bool clear) EAPI void evas_object_table_col_row_size_get(const Evas_Object *o, int *cols, int *rows) { - EVAS_OBJECT_TABLE_DATA_GET(o, priv); + eo_do((Eo *)o, evas_obj_table_col_row_size_get(cols, rows)); +} + +static void +_col_row_size_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + int *cols = va_arg(*list, int *); + int *rows = va_arg(*list, int *); + + const Evas_Object_Table_Data *priv = _pd; if (priv) { if (cols) *cols = priv->size.cols; @@ -1278,14 +1403,32 @@ evas_object_table_col_row_size_get(const Evas_Object *o, int *cols, int *rows) EAPI Eina_Iterator * evas_object_table_iterator_new(const Evas_Object *o) { + Eina_Iterator *ret = NULL; + eo_do((Eo *)o, evas_obj_table_iterator_new(&ret)); + return ret; +} + +static void +_iterator_new(Eo *o, void *_pd, va_list *list) +{ + Eina_Iterator **ret = va_arg(*list, Eina_Iterator **); + Evas_Object_Table_Iterator *it; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, NULL); + const Evas_Object_Table_Data *priv = _pd; - if (!priv->children) return NULL; + if (!priv->children) + { + *ret = NULL; + return; + } it = calloc(1, sizeof(Evas_Object_Table_Iterator)); - if (!it) return NULL; + if (!it) + { + *ret = NULL; + return; + } EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR); @@ -1296,20 +1439,38 @@ evas_object_table_iterator_new(const Evas_Object *o) it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_evas_object_table_iterator_get_container); it->iterator.free = FUNC_ITERATOR_FREE(_evas_object_table_iterator_free); - return &it->iterator; + *ret = &it->iterator; } EAPI Eina_Accessor * evas_object_table_accessor_new(const Evas_Object *o) { + Eina_Accessor *ret = NULL; + eo_do((Eo *)o, evas_obj_table_accessor_new(&ret)); + return ret; +} + +static void +_accessor_new(Eo *o, void *_pd, va_list *list) +{ + Eina_Accessor **ret = va_arg(*list, Eina_Accessor **); + Evas_Object_Table_Accessor *it; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, NULL); + const Evas_Object_Table_Data *priv = _pd; - if (!priv->children) return NULL; + if (!priv->children) + { + *ret = NULL; + return; + } it = calloc(1, sizeof(Evas_Object_Table_Accessor)); - if (!it) return NULL; + if (!it) + { + *ret = NULL; + return; + } EINA_MAGIC_SET(&it->accessor, EINA_MAGIC_ACCESSOR); @@ -1320,21 +1481,31 @@ evas_object_table_accessor_new(const Evas_Object *o) it->accessor.get_container = FUNC_ACCESSOR_GET_CONTAINER(_evas_object_table_accessor_get_container); it->accessor.free = FUNC_ACCESSOR_FREE(_evas_object_table_accessor_free); - return &it->accessor; + *ret = &it->accessor; } EAPI Eina_List * evas_object_table_children_get(const Evas_Object *o) { + Eina_List *ret = NULL; + eo_do((Eo *)o, evas_obj_table_children_get(&ret)); + return ret; +} + +static void +_children_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_List **ret = va_arg(*list, Eina_List **); + Eina_List *new_list = NULL, *l; Evas_Object_Table_Option *opt; - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(o, priv, NULL); + const Evas_Object_Table_Data *priv = _pd; EINA_LIST_FOREACH(priv->children, l, opt) new_list = eina_list_append(new_list, opt->obj); - return new_list; + *ret = new_list; } Evas_Object * @@ -1354,18 +1525,100 @@ evas_object_table_child_get(const Evas_Object *o, unsigned short col, unsigned s EAPI Eina_Bool evas_object_table_mirrored_get(const Evas_Object *obj) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN_VAL(obj, priv, EINA_FALSE); + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)obj, evas_obj_table_mirrored_get(&ret)); + return ret; +} - return priv->is_mirrored; +static void +_mirrored_get(Eo *o EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + + const Evas_Object_Table_Data *priv = _pd; + + *ret = priv->is_mirrored; } EAPI void evas_object_table_mirrored_set(Evas_Object *obj, Eina_Bool mirrored) { - EVAS_OBJECT_TABLE_DATA_GET_OR_RETURN(obj, priv); + eo_do(obj, evas_obj_table_mirrored_set(mirrored)); +} + +static void +_mirrored_set(Eo *o, void *_pd, va_list *list) +{ + Eina_Bool mirrored = va_arg(*list, int); + + Evas_Object_Table_Data *priv = _pd; if (priv->is_mirrored != mirrored) { priv->is_mirrored = mirrored; - _evas_object_table_smart_calculate(obj); + eo_do(o, evas_obj_smart_calculate()); } } + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ADD_TO), _add_to), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_SET), _homogeneous_set), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_GET), _homogeneous_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ALIGN_SET), _align_set), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ALIGN_GET), _align_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PADDING_SET), _padding_set), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PADDING_GET), _padding_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PACK_GET), _pack_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_PACK), _pack), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_UNPACK), _unpack), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_CLEAR), _clear), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_COL_ROW_SIZE_GET), _col_row_size_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ITERATOR_NEW), _iterator_new), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_ACCESSOR_NEW), _accessor_new), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_CHILDREN_GET), _children_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_MIRRORED_GET), _mirrored_get), + EO_OP_FUNC(EVAS_OBJ_TABLE_ID(EVAS_OBJ_TABLE_SUB_ID_MIRRORED_SET), _mirrored_set), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _smart_add), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _smart_del), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _smart_resize), + EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALCULATE), _smart_calculate), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_ADD_TO, "Create a table that is child of a given element parent."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_SET, "Set how this table should layout children."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_HOMOGENEOUS_GET, "Get the current layout homogeneous mode."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_ALIGN_SET, "Set the alignment of the whole bounding box of contents."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_ALIGN_GET, "Get alignment of the whole bounding box of contents."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_PADDING_SET, "Set padding between cells."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_PADDING_GET, "Get padding between cells."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_PACK_GET, "Get packing location of a child of table."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_PACK, "Add a new child to a table object or set its current packing."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_UNPACK, "Remove child from table."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_CLEAR, "Faster way to remove all child objects from a table object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_COL_ROW_SIZE_GET, "Get the number of columns and rows this table takes."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_ITERATOR_NEW, "Get an iterator to walk the list of children for the table."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_ACCESSOR_NEW, "Get an accessor to get random access to the list of children for the table."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_CHILDREN_GET, "Get the list of children for the table."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_MIRRORED_GET, "Gets the mirrored mode of the table."), + EO_OP_DESCRIPTION(EVAS_OBJ_TABLE_SUB_ID_MIRRORED_SET, "Sets the mirrored mode of the table."), + EO_OP_DESCRIPTION_SENTINEL +}; +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Table", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_TABLE_BASE_ID, op_desc, EVAS_OBJ_TABLE_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Table_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_table_class_get, &class_desc, EVAS_OBJ_SMART_CLIPPED_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_text.c b/legacy/evas/src/lib/canvas/evas_object_text.c index 2afc588645..8e436b9036 100644 --- a/legacy/evas/src/lib/canvas/evas_object_text.c +++ b/legacy/evas/src/lib/canvas/evas_object_text.c @@ -1,6 +1,12 @@ #include "evas_common.h" /* Includes evas_bidi_utils stuff. */ #include "evas_private.h" +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_TEXT_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_TEXT_CLASS + /* save typing */ #define ENFN obj->layer->evas->engine.func #define ENDT obj->layer->evas->engine.data.output @@ -51,27 +57,26 @@ struct _Evas_Object_Text_Item }; /* private methods for text objects */ -static void evas_object_text_init(Evas_Object *obj); -static void *evas_object_text_new(void); -static void evas_object_text_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_text_free(Evas_Object *obj); -static void evas_object_text_render_pre(Evas_Object *obj); -static void evas_object_text_render_post(Evas_Object *obj); +static void evas_object_text_init(Evas_Object *eo_obj); +static void evas_object_text_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_text_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_text_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_text_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_text_id_get(Evas_Object *obj); -static unsigned int evas_object_text_visual_id_get(Evas_Object *obj); -static void *evas_object_text_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_text_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_text_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_text_engine_data_get(Evas_Object *eo_obj); -static int evas_object_text_is_opaque(Evas_Object *obj); -static int evas_object_text_was_opaque(Evas_Object *obj); +static int evas_object_text_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_text_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static void evas_object_text_scale_update(Evas_Object *obj); -static void _evas_object_text_recalc(Evas_Object *obj); +static void evas_object_text_scale_update(Evas_Object *eo_obj); +static void _evas_object_text_recalc(Evas_Object *eo_obj); static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_text_free, + NULL, evas_object_text_render, evas_object_text_render_pre, evas_object_text_render_post, @@ -97,13 +102,12 @@ static const Evas_Object_Func object_func = /* the actual api call to add a rect */ /* it has no other api calls as all properties are standard */ -EVAS_MEMPOOL(_mp_obj); - static int -_evas_object_text_char_coords_get(const Evas_Object *obj, +_evas_object_text_char_coords_get(const Evas_Object *eo_obj, const Evas_Object_Text *o, size_t pos, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); Evas_Object_Text_Item *it; EINA_INLIST_FOREACH(EINA_INLIST_GET(o->items), it) @@ -159,9 +163,10 @@ _evas_object_text_it_compare_logical(const void *_it1, const void *_it2) #endif static int -_evas_object_text_last_up_to_pos(const Evas_Object *obj, +_evas_object_text_last_up_to_pos(const Evas_Object *eo_obj, const Evas_Object_Text *o, Evas_Coord cx, Evas_Coord cy) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); Evas_Object_Text_Item *it; #ifdef BIDI_SUPPORT @@ -212,10 +217,11 @@ _evas_object_text_last_up_to_pos(const Evas_Object *obj, } static int -_evas_object_text_char_at_coords(const Evas_Object *obj, +_evas_object_text_char_at_coords(const Evas_Object *eo_obj, const Evas_Object_Text *o, Evas_Coord cx, Evas_Coord cy, Evas_Coord *rx, Evas_Coord *ry, Evas_Coord *rw, Evas_Coord *rh) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); Evas_Object_Text_Item *it; EINA_INLIST_FOREACH(EINA_INLIST_GET(o->items), it) @@ -235,12 +241,12 @@ _evas_object_text_char_at_coords(const Evas_Object *obj, } static Evas_Coord -_evas_object_text_horiz_advance_get(const Evas_Object *obj, +_evas_object_text_horiz_advance_get(const Evas_Object *eo_obj, const Evas_Object_Text *o) { Evas_Object_Text_Item *it, *last_it = NULL; Evas_Coord adv; - (void) obj; + (void) eo_obj; adv = 0; EINA_INLIST_FOREACH(EINA_INLIST_GET(o->items), it) @@ -264,30 +270,38 @@ _evas_object_text_vert_advance_get(const Evas_Object *obj __UNUSED__, EAPI Evas_Object * evas_object_text_add(Evas *e) { - Evas_Object *obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - obj = evas_object_new(e); - evas_object_text_init(obj); - evas_object_inject(obj, e); - return obj; + Evas_Object *eo_obj = eo_add(EVAS_OBJ_TEXT_CLASS, e); + eo_unref(eo_obj); + return eo_obj; +} + +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); + evas_object_text_init(eo_obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); } EAPI void -evas_object_text_font_source_set(Evas_Object *obj, const char *font_source) +evas_object_text_font_source_set(Evas_Object *eo_obj, const char *font_source) { - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_font_source_set(font_source)); +} +static void +_text_font_source_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Text *o = _pd; + + const char *font_source = va_arg(*list, const char *); if ((o->cur.source) && (font_source) && (!strcmp(o->cur.source, font_source))) return; @@ -300,35 +314,45 @@ evas_object_text_font_source_set(Evas_Object *obj, const char *font_source) } EAPI const char * -evas_object_text_font_source_get(const Evas_Object *obj) +evas_object_text_font_source_get(const Evas_Object *eo_obj) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + const char *font_source = NULL; + eo_do((Eo *)eo_obj, evas_obj_text_font_source_get(&font_source)); + return font_source; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return NULL; - MAGIC_CHECK_END(); - return o->cur.source; +static void +_text_font_source_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Text *o = _pd; + + const char ** font_source = va_arg(*list, const char **); + *font_source = o->cur.source; } EAPI void -evas_object_text_font_set(Evas_Object *obj, const char *font, Evas_Font_Size size) +evas_object_text_font_set(Evas_Object *eo_obj, const char *font, Evas_Font_Size size) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_font_set(font, size)); +} + +static void +_text_font_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Text *o = _pd; int is, was = 0, pass = 0, freeze = 0; Evas_Font_Description *fdesc; + const char *font = va_arg(*list, const char*); + Evas_Font_Size size = va_arg(*list, Evas_Font_Size); + if ((!font) || (size <= 0)) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); fdesc = evas_font_desc_new(); evas_font_name_parse(fdesc, font); @@ -346,12 +370,13 @@ evas_object_text_font_set(Evas_Object *obj, const char *font, Evas_Font_Size siz eina_stringshare_replace(&o->cur.font, font); o->prev.font = NULL; - if (obj->layer->evas->events_frozen <= 0) + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!(obj->layer->evas->is_frozen)) { - pass = evas_event_passes_through(obj); - freeze = evas_event_freezes_through(obj); + pass = evas_event_passes_through(eo_obj, obj); + freeze = evas_event_freezes_through(eo_obj, obj); if ((!pass) && (!freeze)) - was = evas_object_is_in_output_rect(obj, + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); } @@ -359,11 +384,11 @@ evas_object_text_font_set(Evas_Object *obj, const char *font, Evas_Font_Size siz /* DO IT */ if (o->font) { - evas_font_free(obj->layer->evas, o->font); + evas_font_free(obj->layer->evas->evas, o->font); o->font = NULL; } - o->font = evas_font_load(obj->layer->evas, o->cur.fdesc, o->cur.source, + o->font = evas_font_load(obj->layer->evas->evas, o->cur.fdesc, o->cur.source, (int)(((double) o->cur.size) * obj->cur.scale)); if (o->font) { @@ -379,46 +404,48 @@ evas_object_text_font_set(Evas_Object *obj, const char *font, Evas_Font_Size siz o->max_ascent = 0; o->max_descent = 0; } - _evas_object_text_recalc(obj); + _evas_object_text_recalc(eo_obj); o->changed = 1; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_coords_recalc(obj); - if (obj->layer->evas->events_frozen <= 0) + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + if (!(obj->layer->evas->is_frozen)) { if ((!pass) && (!freeze)) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is ^ was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } } - evas_object_inform_call_resize(obj); + evas_object_inform_call_resize(eo_obj); } EAPI void -evas_object_text_font_get(const Evas_Object *obj, const char **font, Evas_Font_Size *size) +evas_object_text_font_get(const Evas_Object *eo_obj, const char **font, Evas_Font_Size *size) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (font) *font = ""; + if (size) *size = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_text_font_get(font, size)); +} + +static void +_text_font_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Text *o = _pd; + const char **font = va_arg(*list, const char **); + Evas_Font_Size *size = va_arg(*list, Evas_Font_Size *); - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (font) *font = ""; - if (size) *size = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - if (font) *font = ""; - if (size) *size = 0; - return; - MAGIC_CHECK_END(); if (font) *font = o->cur.font; if (size) *size = o->cur.size; } @@ -433,10 +460,11 @@ evas_object_text_font_get(const Evas_Object *obj, const char **font, Evas_Font_S * @param str the string to use. */ static Evas_Object_Text_Item * -_evas_object_text_item_new(Evas_Object *obj, Evas_Object_Text *o, +_evas_object_text_item_new(Evas_Object *eo_obj, Evas_Object_Text *o, Evas_Font_Instance *fi, const Eina_Unicode *str, Evas_Script_Type script, size_t pos, size_t visual_pos, size_t len) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); Evas_Object_Text_Item *it; it = calloc(1, sizeof(Evas_Object_Text_Item)); @@ -472,9 +500,9 @@ _evas_object_text_item_new(Evas_Object *obj, Evas_Object_Text *o, * @param o the text object */ static void -_evas_object_text_item_order(Evas_Object *obj, Evas_Object_Text *o) +_evas_object_text_item_order(Evas_Object *eo_obj, Evas_Object_Text *o) { - (void) obj; + (void) eo_obj; #ifdef BIDI_SUPPORT /*FIXME: not very efficient, sort the items arrays. */ /* Reorder if it's a bidi text */ @@ -526,8 +554,9 @@ _evas_object_text_item_order(Evas_Object *obj, Evas_Object_Text *o) * @param text the text to layout */ static void -_evas_object_text_layout(Evas_Object *obj, Evas_Object_Text *o, const Eina_Unicode *text) +_evas_object_text_layout(Evas_Object *eo_obj, Evas_Object_Text *o, const Eina_Unicode *text) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); EvasBiDiStrIndex *v_to_l = NULL; size_t pos, visual_pos; int len = eina_unicode_strlen(text); @@ -573,7 +602,7 @@ _evas_object_text_layout(Evas_Object *obj, Evas_Object_Text *o, const Eina_Unico #else visual_pos = pos; #endif - _evas_object_text_item_new(obj, o, cur_fi, text, script, + _evas_object_text_item_new(eo_obj, o, cur_fi, text, script, pos, visual_pos, run_len); pos += run_len; @@ -582,33 +611,37 @@ _evas_object_text_layout(Evas_Object *obj, Evas_Object_Text *o, const Eina_Unico } } - _evas_object_text_item_order(obj, o); + _evas_object_text_item_order(eo_obj, o); if (v_to_l) free(v_to_l); } EAPI void -evas_object_text_text_set(Evas_Object *obj, const char *_text) +evas_object_text_text_set(Evas_Object *eo_obj, const char *_text) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_text_set(_text)); +} + +static void +_text_text_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Text *o = _pd; int is, was, len; Eina_Unicode *text; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); + + const char *_text = va_arg(*list, const char *); if ((o->cur.utf8_text) && (_text) && (!strcmp(o->cur.utf8_text, _text))) return; text = eina_unicode_utf8_to_unicode(_text, &len); if (!text) text = eina_unicode_strdup(EINA_UNICODE_EMPTY_STRING); - was = evas_object_is_in_output_rect(obj, + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); /* DO II */ @@ -616,13 +649,13 @@ evas_object_text_text_set(Evas_Object *obj, const char *_text) if (o->items) _evas_object_text_items_clear(o); - if ((text) && (*text)) + if ((text) && (*text)) { - _evas_object_text_layout(obj, o, text); + _evas_object_text_layout(eo_obj, o, text); eina_stringshare_replace(&o->cur.utf8_text, _text); o->prev.utf8_text = NULL; } - else + else { eina_stringshare_replace(&o->cur.utf8_text, NULL); } @@ -631,219 +664,279 @@ evas_object_text_text_set(Evas_Object *obj, const char *_text) free(text); text = NULL; } - _evas_object_text_recalc(obj); + _evas_object_text_recalc(eo_obj); o->changed = 1; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_coords_recalc(obj); - is = evas_object_is_in_output_rect(obj, + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is || was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); - evas_object_inform_call_resize(obj); + evas_object_inform_call_resize(eo_obj); if (text) free(text); } EAPI void -evas_object_text_bidi_delimiters_set(Evas_Object *obj, const char *delim) +evas_object_text_bidi_delimiters_set(Evas_Object *eo_obj, const char *delim) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_bidi_delimiters_set(delim)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); +static void +_text_bidi_delimiters_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Text *o = _pd; + + const char *delim = va_arg(*list, const char *); eina_stringshare_replace(&o->bidi_delimiters, delim); } EAPI const char * -evas_object_text_bidi_delimiters_get(const Evas_Object *obj) +evas_object_text_bidi_delimiters_get(const Evas_Object *eo_obj) { - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return NULL; - MAGIC_CHECK_END(); - - return o->bidi_delimiters; + const char *delim = NULL; + eo_do((Eo *)eo_obj, evas_obj_text_bidi_delimiters_get(&delim)); + return delim; } +static void +_text_bidi_delimiters_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Text *o = _pd; + const char **delim = va_arg(*list, const char **); + *delim = o->bidi_delimiters; +} EAPI const char * -evas_object_text_text_get(const Evas_Object *obj) +evas_object_text_text_get(const Evas_Object *eo_obj) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return NULL; + MAGIC_CHECK_END(); + const char *text = NULL; + eo_do((Eo *)eo_obj, evas_obj_text_text_get(&text)); + return text; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return NULL; - MAGIC_CHECK_END(); - return o->cur.utf8_text; +static void +_text_text_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const char **text = va_arg(*list, const char **); + const Evas_Object_Text *o = _pd; + *text = o->cur.utf8_text; } EAPI Evas_BiDi_Direction -evas_object_text_direction_get(const Evas_Object *obj) +evas_object_text_direction_get(const Evas_Object *eo_obj) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_BIDI_DIRECTION_NEUTRAL; + MAGIC_CHECK_END(); + Evas_BiDi_Direction bidi_dir = EVAS_BIDI_DIRECTION_NEUTRAL; + eo_do((Eo *)eo_obj, evas_obj_text_direction_get(&bidi_dir)); + return bidi_dir; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_BIDI_DIRECTION_NEUTRAL; +static void +_text_direction_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_BiDi_Direction *bidi_dir = va_arg(*list, Evas_BiDi_Direction *); + const Evas_Object_Text *o = _pd; + *bidi_dir = o->items ? o->items->text_props.bidi.dir : EVAS_BIDI_DIRECTION_NEUTRAL; +} + +EAPI Evas_Coord +evas_object_text_ascent_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return EVAS_BIDI_DIRECTION_NEUTRAL; + Evas_Coord ascent = 0; + eo_do((Eo *)eo_obj, evas_obj_text_ascent_get(&ascent)); + return ascent; +} + +static void +_text_ascent_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *ascent = va_arg(*list, Evas_Coord *); + const Evas_Object_Text *o = _pd; + *ascent = o->ascent; +} + +EAPI Evas_Coord +evas_object_text_descent_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; MAGIC_CHECK_END(); - if (o->items) + Evas_Coord descent = 0; + eo_do((Eo *)eo_obj, evas_obj_text_descent_get(&descent)); + return descent; +} + +static void +_text_descent_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *descent = va_arg(*list, Evas_Coord *); + const Evas_Object_Text *o = _pd; + *descent = o->descent; +} + +EAPI Evas_Coord +evas_object_text_max_ascent_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Coord max_ascent = 0; + eo_do((Eo *)eo_obj, evas_obj_text_max_ascent_get(&max_ascent)); + return max_ascent; +} + +static void +_text_max_ascent_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *max_ascent = va_arg(*list, Evas_Coord *); + const Evas_Object_Text *o = _pd; + *max_ascent = o->max_ascent; +} + +EAPI Evas_Coord +evas_object_text_max_descent_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Coord max_descent = 0; + eo_do((Eo *)eo_obj, evas_obj_text_max_descent_get(&max_descent)); + return max_descent; +} + +static void +_text_max_descent_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Coord *max_descent = va_arg(*list, Evas_Coord *); + const Evas_Object_Text *o = _pd; + *max_descent = o->max_descent; +} + +EAPI Evas_Coord +evas_object_text_inset_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Coord inset = 0; + eo_do((Eo *)eo_obj, evas_obj_text_inset_get(&inset)); + return inset; +} + +static void +_text_inset_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Coord *inset = va_arg(*list, Evas_Coord *); + *inset = 0; + const Evas_Object_Text *o = _pd; + if (!o->font) return; + if (!o->items) return; + *inset = ENFN->font_inset_get(ENDT, o->font, &o->items->text_props); +} + +EAPI Evas_Coord +evas_object_text_horiz_advance_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Coord horiz = 0; + eo_do((Eo *)eo_obj, evas_obj_text_horiz_advance_get(&horiz)); + return horiz; +} + +static void +_text_horiz_advance_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Coord *horiz = va_arg(*list, Evas_Coord *); + *horiz = 0; + const Evas_Object_Text *o = _pd; + if (!o->font) return; + if (!o->items) return; + *horiz = _evas_object_text_horiz_advance_get(eo_obj, o); +} + +EAPI Evas_Coord +evas_object_text_vert_advance_get(const Evas_Object *eo_obj) +{ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return 0; + MAGIC_CHECK_END(); + Evas_Coord vert = 0; + eo_do((Eo *)eo_obj, evas_obj_text_vert_advance_get(&vert)); + return vert; +} + +static void +_text_vert_advance_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Coord *vert = va_arg(*list, Evas_Coord *); + *vert = 0; + const Evas_Object_Text *o = _pd; + if (!o->font) return; + if (!o->items) { - return o->items->text_props.bidi.dir; + *vert = o->ascent + o->descent; + return; } - return EVAS_BIDI_DIRECTION_NEUTRAL; -} - -EAPI Evas_Coord -evas_object_text_ascent_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - return o->ascent; -} - -EAPI Evas_Coord -evas_object_text_descent_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - return o->descent; -} - -EAPI Evas_Coord -evas_object_text_max_ascent_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - return o->max_ascent; -} - -EAPI Evas_Coord -evas_object_text_max_descent_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - return o->max_descent; -} - -EAPI Evas_Coord -evas_object_text_inset_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - if (!o->font) return 0; - if (!o->items) return 0; - return ENFN->font_inset_get(ENDT, o->font, &o->items->text_props); -} - -EAPI Evas_Coord -evas_object_text_horiz_advance_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - if (!o->font) return 0; - if (!o->items) return 0; - return _evas_object_text_horiz_advance_get(obj, o); -} - -EAPI Evas_Coord -evas_object_text_vert_advance_get(const Evas_Object *obj) -{ - Evas_Object_Text *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return 0; - MAGIC_CHECK_END(); - if (!o->font) return 0; - if (!o->items) return o->ascent + o->descent; - return _evas_object_text_vert_advance_get(obj, o); + *vert = _evas_object_text_vert_advance_get(eo_obj, o); } EAPI Eina_Bool -evas_object_text_char_pos_get(const Evas_Object *obj, int pos, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) +evas_object_text_char_pos_get(const Evas_Object *eo_obj, int pos, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { - Evas_Object_Text *o; - int l = 0, r = 0, t = 0, b = 0; - int ret, x = 0, y = 0, w = 0, h = 0; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EINA_FALSE; + MAGIC_CHECK_END(); + Eina_Bool ret = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_text_char_pos_get(pos, cx, cy, cw, ch, &ret)); + return ret; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return EINA_FALSE; - MAGIC_CHECK_END(); - if (!o->font) return EINA_FALSE; - if (!o->items || (pos < 0)) return EINA_FALSE; - ret = _evas_object_text_char_coords_get(obj, o, (size_t) pos, +static void +_text_char_pos_get(Eo *eo_obj, void *_pd, va_list *list) +{ + int pos = va_arg(*list, int); + Evas_Coord *cx = va_arg(*list, Evas_Coord *); + Evas_Coord *cy = va_arg(*list, Evas_Coord *); + Evas_Coord *cw = va_arg(*list, Evas_Coord *); + Evas_Coord *ch = va_arg(*list, Evas_Coord *); + Eina_Bool *ret = va_arg(*list, Eina_Bool *); + if (ret) *ret = EINA_FALSE; + + const Evas_Object_Text *o = _pd; + int l = 0, r = 0, t = 0, b = 0; + int x = 0, y = 0, w = 0, h = 0; + + if (!o->font) return; + if (!o->items || (pos < 0)) return; + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + + Eina_Bool int_ret = _evas_object_text_char_coords_get(eo_obj, o, (size_t) pos, &x, &y, &w, &h); evas_text_style_pad_get(o->cur.style, &l, &r, &t, &b); y += o->max_ascent - t; @@ -866,44 +959,68 @@ evas_object_text_char_pos_get(const Evas_Object *obj, int pos, Evas_Coord *cx, E if (cy) *cy = y; if (cw) *cw = w + l + r; if (ch) *ch = h + t + b; - return ret; + if (ret) *ret = int_ret; } EAPI int -evas_object_text_last_up_to_pos(const Evas_Object *obj, Evas_Coord x, Evas_Coord y) +evas_object_text_last_up_to_pos(const Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return -1; + MAGIC_CHECK_END(); + int res = -1; + eo_do((Eo *)eo_obj, evas_obj_text_last_up_to_pos(x, y, &res)); + return res; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return -1; - MAGIC_CHECK_END(); - if (!o->font) return -1; - if (!o->items) return -1; - return _evas_object_text_last_up_to_pos(obj, o, x, y - o->max_ascent); +static void +_text_last_up_to_pos(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + int *ret = va_arg(*list, int *); + *ret = -1; + + const Evas_Object_Text *o = _pd; + + if (!o->font) return; + if (!o->items) return; + int int_ret = _evas_object_text_last_up_to_pos(eo_obj, o, x, y - o->max_ascent); + if (ret) *ret = int_ret; } EAPI int -evas_object_text_char_coords_get(const Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) +evas_object_text_char_coords_get(const Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return -1; + MAGIC_CHECK_END(); + int res = -1; + eo_do((Eo *)eo_obj, evas_obj_text_char_coords_get(x, y, cx, cy, cw, ch, &res)); + return res; +} + +static void +_text_char_coords_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Coord x = va_arg(*list, Evas_Coord); + Evas_Coord y = va_arg(*list, Evas_Coord); + Evas_Coord *cx = va_arg(*list, Evas_Coord *); + Evas_Coord *cy = va_arg(*list, Evas_Coord *); + Evas_Coord *cw = va_arg(*list, Evas_Coord *); + Evas_Coord *ch = va_arg(*list, Evas_Coord *); + int *ret = va_arg(*list, int *); + if (ret) *ret = -1; + + const Evas_Object_Text *o = _pd; int l = 0, r = 0, t = 0, b = 0; - int ret, rx = 0, ry = 0, rw = 0, rh = 0; + int rx = 0, ry = 0, rw = 0, rh = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return -1; - MAGIC_CHECK_END(); - if (!o->font) return -1; - if (!o->items) return -1; - ret = _evas_object_text_char_at_coords(obj, o, x, y - o->max_ascent, + if (!o->font) return; + if (!o->items) return; + + int int_ret = _evas_object_text_char_at_coords(eo_obj, o, x, y - o->max_ascent, &rx, &ry, &rw, &rh); evas_text_style_pad_get(o->cur.style, &l, &r, &t, &b); ry += o->max_ascent - t; @@ -913,6 +1030,7 @@ evas_object_text_char_coords_get(const Evas_Object *obj, Evas_Coord x, Evas_Coor rw += rx; rx = 0; } + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if ((rx + rw) > obj->cur.geometry.w) rw = obj->cur.geometry.w - rx; if (rw < 0) rw = 0; if (ry < 0) @@ -926,23 +1044,28 @@ evas_object_text_char_coords_get(const Evas_Object *obj, Evas_Coord x, Evas_Coor if (cy) *cy = ry; if (cw) *cw = rw + l + r; if (ch) *ch = rh + t + b; - return ret; + if (ret) *ret = int_ret; } EAPI void -evas_object_text_style_set(Evas_Object *obj, Evas_Text_Style_Type style) +evas_object_text_style_set(Evas_Object *eo_obj, Evas_Text_Style_Type style) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_style_set(style)); +} + +static void +_text_style_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Text_Style_Type style = va_arg(*list, Evas_Text_Style_Type); + Evas_Object_Text *o = _pd; int pl = 0, pr = 0, pt = 0, pb = 0, l = 0, r = 0, t = 0, b = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); if (o->cur.style == style) return; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_text_style_pad_get(o->cur.style, &pl, &pr, &pt, &pb); o->cur.style = style; evas_text_style_pad_get(o->cur.style, &l, &r, &t, &b); @@ -951,37 +1074,47 @@ evas_object_text_style_set(Evas_Object *obj, Evas_Text_Style_Type style) else obj->cur.geometry.w = 0; obj->cur.geometry.h += (t - pt) + (b - pb); - evas_object_change(obj); - evas_object_clip_dirty(obj); + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); } EAPI Evas_Text_Style_Type -evas_object_text_style_get(const Evas_Object *obj) +evas_object_text_style_get(const Evas_Object *eo_obj) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_TEXT_STYLE_PLAIN; + MAGIC_CHECK_END(); + Evas_Text_Style_Type style = EVAS_TEXT_STYLE_PLAIN; + eo_do((Eo *)eo_obj, evas_obj_text_style_get(&style)); + return style; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_TEXT_STYLE_PLAIN; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return EVAS_TEXT_STYLE_PLAIN; - MAGIC_CHECK_END(); - return o->cur.style; +static void +_text_style_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Text_Style_Type *style = va_arg(*list, Evas_Text_Style_Type *); + const Evas_Object_Text *o = _pd; + *style = o->cur.style; } EAPI void -evas_object_text_shadow_color_set(Evas_Object *obj, int r, int g, int b, int a) +evas_object_text_shadow_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_shadow_color_set(r, g, b, a)); +} + +static void +_text_shadow_color_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + Evas_Object_Text *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); if ((o->cur.shadow.r == r) && (o->cur.shadow.g == g) && (o->cur.shadow.b == b) && (o->cur.shadow.a == a)) return; @@ -990,29 +1123,28 @@ evas_object_text_shadow_color_set(Evas_Object *obj, int r, int g, int b, int a) o->cur.shadow.b = b; o->cur.shadow.a = a; o->changed = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_text_shadow_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) +evas_object_text_shadow_color_get(const Evas_Object *eo_obj, int *r, int *g, int *b, int *a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_text_shadow_color_get(r, g, b, a)); +} + +static void +_text_shadow_color_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *r = va_arg(*list, int *); + int *g = va_arg(*list, int *); + int *b = va_arg(*list, int *); + int *a = va_arg(*list, int *); + const Evas_Object_Text *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); if (r) *r = o->cur.shadow.r; if (g) *g = o->cur.shadow.g; if (b) *b = o->cur.shadow.b; @@ -1020,17 +1152,23 @@ evas_object_text_shadow_color_get(const Evas_Object *obj, int *r, int *g, int *b } EAPI void -evas_object_text_glow_color_set(Evas_Object *obj, int r, int g, int b, int a) +evas_object_text_glow_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_glow_color_set(r, g, b, a)); +} + +static void +_text_glow_color_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + Evas_Object_Text *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); if ((o->cur.glow.r == r) && (o->cur.glow.g == g) && (o->cur.glow.b == b) && (o->cur.glow.a == a)) return; @@ -1039,29 +1177,31 @@ evas_object_text_glow_color_set(Evas_Object *obj, int r, int g, int b, int a) o->cur.glow.b = b; o->cur.glow.a = a; o->changed = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_text_glow_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) +evas_object_text_glow_color_get(const Evas_Object *eo_obj, int *r, int *g, int *b, int *a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (r) *r = 0; + if (g) *g = 0; + if (b) *b = 0; + if (a) *a = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_text_glow_color_get(r, g, b, a)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); +static void +_text_glow_color_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *r = va_arg(*list, int *); + int *g = va_arg(*list, int *); + int *b = va_arg(*list, int *); + int *a = va_arg(*list, int *); + const Evas_Object_Text *o = _pd; if (r) *r = o->cur.glow.r; if (g) *g = o->cur.glow.g; if (b) *b = o->cur.glow.b; @@ -1069,17 +1209,23 @@ evas_object_text_glow_color_get(const Evas_Object *obj, int *r, int *g, int *b, } EAPI void -evas_object_text_glow2_color_set(Evas_Object *obj, int r, int g, int b, int a) +evas_object_text_glow2_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_glow2_color_set(r, g, b, a)); +} + +static void +_text_glow2_color_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + Evas_Object_Text *o = _pd; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); if ((o->cur.glow2.r == r) && (o->cur.glow2.g == g) && (o->cur.glow2.b == b) && (o->cur.glow2.a == a)) return; @@ -1088,29 +1234,31 @@ evas_object_text_glow2_color_set(Evas_Object *obj, int r, int g, int b, int a) o->cur.glow2.b = b; o->cur.glow2.a = a; o->changed = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_text_glow2_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) +evas_object_text_glow2_color_get(const Evas_Object *eo_obj, int *r, int *g, int *b, int *a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (r) *r = 0; + if (g) *g = 0; + if (b) *b = 0; + if (a) *a = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_text_glow2_color_get(r, g, b, a)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); +static void +_text_glow2_color_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *r = va_arg(*list, int *); + int *g = va_arg(*list, int *); + int *b = va_arg(*list, int *); + int *a = va_arg(*list, int *); + const Evas_Object_Text *o = _pd; if (r) *r = o->cur.glow2.r; if (g) *g = o->cur.glow2.g; if (b) *b = o->cur.glow2.b; @@ -1118,17 +1266,22 @@ evas_object_text_glow2_color_get(const Evas_Object *obj, int *r, int *g, int *b, } EAPI void -evas_object_text_outline_color_set(Evas_Object *obj, int r, int g, int b, int a) +evas_object_text_outline_color_set(Evas_Object *eo_obj, int r, int g, int b, int a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_text_outline_color_set(r, g, b, a)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); +static void +_text_outline_color_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + Evas_Object_Text *o = _pd; if ((o->cur.outline.r == r) && (o->cur.outline.g == g) && (o->cur.outline.b == b) && (o->cur.outline.a == a)) return; @@ -1137,29 +1290,31 @@ evas_object_text_outline_color_set(Evas_Object *obj, int r, int g, int b, int a) o->cur.outline.b = b; o->cur.outline.a = a; o->changed = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_text_outline_color_get(const Evas_Object *obj, int *r, int *g, int *b, int *a) +evas_object_text_outline_color_get(const Evas_Object *eo_obj, int *r, int *g, int *b, int *a) { - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ) + if (r) *r = 0; + if (g) *g = 0; + if (b) *b = 0; + if (a) *a = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_text_outline_color_get(r, g, b, a)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - if (a) *a = 0; - return; - MAGIC_CHECK_END(); +static void +_text_outline_color_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *r = va_arg(*list, int *); + int *g = va_arg(*list, int *); + int *b = va_arg(*list, int *); + int *a = va_arg(*list, int *); + const Evas_Object_Text *o = _pd; if (r) *r = o->cur.outline.r; if (g) *g = o->cur.outline.g; if (b) *b = o->cur.outline.b; @@ -1167,26 +1322,27 @@ evas_object_text_outline_color_get(const Evas_Object *obj, int *r, int *g, int * } EAPI void -evas_object_text_style_pad_get(const Evas_Object *obj, int *l, int *r, int *t, int *b) +evas_object_text_style_pad_get(const Evas_Object *eo_obj, int *l, int *r, int *t, int *b) { - int sl = 0, sr = 0, st = 0, sb = 0; - Evas_Object_Text *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (l) *l = 0; + if (r) *r = 0; + if (t) *t = 0; + if (b) *b = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_text_style_pad_get(l, r, t, b)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (l) *l = 0; - if (r) *r = 0; - if (t) *t = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - if (l) *l = 0; - if (r) *r = 0; - if (t) *t = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); +static void +_text_style_pad_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *l = va_arg(*list, int *); + int *r = va_arg(*list, int *); + int *t = va_arg(*list, int *); + int *b = va_arg(*list, int *); + int sl = 0, sr = 0, st = 0, sb = 0; + const Evas_Object_Text *o = _pd; /* use temps to be certain we have initialized values */ evas_text_style_pad_get(o->cur.style, &sl, &sr, &st, &sb); if (l) *l = sl; @@ -1360,10 +1516,9 @@ evas_text_style_pad_get(Evas_Text_Style_Type style, int *l, int *r, int *t, int /* all nice and private */ static void -evas_object_text_init(Evas_Object *obj) +evas_object_text_init(Evas_Object *eo_obj) { - /* alloc text ob, setup methods and default values */ - obj->object_data = evas_object_text_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -1379,55 +1534,45 @@ evas_object_text_init(Evas_Object *obj) /* set up methods (compulsory) */ obj->func = &object_func; obj->type = o_type; -} - -static void * -evas_object_text_new(void) -{ - Evas_Object_Text *o; + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_text", Evas_Object_Text, 8, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Text); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Text); - o->magic = MAGIC_OBJ_TEXT; o->prev = o->cur; #ifdef BIDI_SUPPORT o->bidi_par_props = evas_bidi_paragraph_props_new(); #endif - return o; } static void -evas_object_text_free(Evas_Object *obj) +_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - Evas_Object_Text *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_text_free(eo_obj, obj); + eo_do_super(eo_obj, eo_destructor()); +} + +static void +evas_object_text_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) +{ + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); - /* frees private object data. very simple here */ - o = (Evas_Object_Text *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Text, MAGIC_OBJ_TEXT); - return; - MAGIC_CHECK_END(); /* free obj */ if (o->items) _evas_object_text_items_clear(o); if (o->cur.utf8_text) eina_stringshare_del(o->cur.utf8_text); if (o->cur.font) eina_stringshare_del(o->cur.font); if (o->cur.fdesc) evas_font_desc_unref(o->cur.fdesc); if (o->cur.source) eina_stringshare_del(o->cur.source); - if (o->font) evas_font_free(obj->layer->evas, o->font); + if (o->font) evas_font_free(obj->layer->evas->evas, o->font); #ifdef BIDI_SUPPORT evas_bidi_paragraph_props_unref(o->bidi_par_props); #endif - o->magic = 0; - EVAS_MEMPOOL_FREE(_mp_obj, o); } static void -evas_object_text_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_text_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { int i, j; - Evas_Object_Text *o; + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); Evas_Object_Text_Item *it; const char vals[5][5] = { @@ -1441,7 +1586,6 @@ evas_object_text_render(Evas_Object *obj, void *output, void *context, void *sur int shad_dst, shad_sz, dx, dy, haveshad; /* render object to surface with context, and offxet by x,y */ - o = (Evas_Object_Text *)(obj->object_data); evas_text_style_pad_get(o->cur.style, &sl, NULL, &st, NULL); ENFN->context_multiplier_unset(output, context); ENFN->context_render_op_set(output, context, obj->cur.render_op); @@ -1472,11 +1616,14 @@ evas_object_text_render(Evas_Object *obj, void *output, void *context, void *sur #define COLOR_SET(object, sub, col) \ if (obj->cur.clipper)\ + { \ + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); \ ENFN->context_color_set(output, context, \ - ((int)object->sub.col.r * ((int)obj->cur.clipper->cur.cache.clip.r + 1)) >> 8, \ - ((int)object->sub.col.g * ((int)obj->cur.clipper->cur.cache.clip.g + 1)) >> 8, \ - ((int)object->sub.col.b * ((int)obj->cur.clipper->cur.cache.clip.b + 1)) >> 8, \ - ((int)object->sub.col.a * ((int)obj->cur.clipper->cur.cache.clip.a + 1)) >> 8); \ + ((int)object->sub.col.r * ((int)cur_clipper->cur.cache.clip.r + 1)) >> 8, \ + ((int)object->sub.col.g * ((int)cur_clipper->cur.cache.clip.g + 1)) >> 8, \ + ((int)object->sub.col.b * ((int)cur_clipper->cur.cache.clip.b + 1)) >> 8, \ + ((int)object->sub.col.a * ((int)cur_clipper->cur.cache.clip.a + 1)) >> 8); \ + } \ else\ ENFN->context_color_set(output, context, \ object->sub.col.r, \ @@ -1486,11 +1633,14 @@ evas_object_text_render(Evas_Object *obj, void *output, void *context, void *sur #define COLOR_SET_AMUL(object, sub, col, amul) \ if (obj->cur.clipper) \ + { \ + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); \ ENFN->context_color_set(output, context, \ - (((int)object->sub.col.r) * ((int)obj->cur.clipper->cur.cache.clip.r) * (amul)) / 65025, \ - (((int)object->sub.col.g) * ((int)obj->cur.clipper->cur.cache.clip.g) * (amul)) / 65025, \ - (((int)object->sub.col.b) * ((int)obj->cur.clipper->cur.cache.clip.b) * (amul)) / 65025, \ - (((int)object->sub.col.a) * ((int)obj->cur.clipper->cur.cache.clip.a) * (amul)) / 65025); \ + (((int)object->sub.col.r) * ((int)cur_clipper->cur.cache.clip.r) * (amul)) / 65025, \ + (((int)object->sub.col.g) * ((int)cur_clipper->cur.cache.clip.g) * (amul)) / 65025, \ + (((int)object->sub.col.b) * ((int)cur_clipper->cur.cache.clip.b) * (amul)) / 65025, \ + (((int)object->sub.col.a) * ((int)cur_clipper->cur.cache.clip.a) * (amul)) / 65025); \ + } \ else \ ENFN->context_color_set(output, context, \ (((int)object->sub.col.r) * (amul)) / 255, \ @@ -1668,9 +1818,9 @@ evas_object_text_render(Evas_Object *obj, void *output, void *context, void *sur } static void -evas_object_text_render_pre(Evas_Object *obj) +evas_object_text_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Text *o; + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); int is_v, was_v; /* dont pre-render the obj twice! */ @@ -1681,39 +1831,39 @@ evas_object_text_render_pre(Evas_Object *obj) elsewhere, decoding video etc. Then when this is done the object needs to figure if it changed and if so what and where and add the appropriate redraw rectangles */ - o = (Evas_Object_Text *)(obj->object_data); /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { + Evas_Object_Protected_Data *clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + evas_object_clip_recalc(obj->cur.clipper, clipper); + clipper->func->render_pre(obj->cur.clipper, clipper); } /* now figure what changed and add draw rects if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); if (is_v != was_v) { evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, - obj, is_v, was_v); + eo_obj, is_v, was_v); goto done; } if (obj->changed_map) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, + eo_obj, obj); goto done; } /* its not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj); /* if we restacked (layer or just within a layer) and dont clip anyone */ if (obj->restack) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } /* if it changed color */ @@ -1723,7 +1873,7 @@ evas_object_text_render_pre(Evas_Object *obj) (obj->cur.color.a != obj->prev.color.a)) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } /* if it changed geometry - and obviously not visibility or color @@ -1735,19 +1885,19 @@ evas_object_text_render_pre(Evas_Object *obj) (obj->cur.geometry.h != obj->prev.geometry.h)) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } if (obj->cur.render_op != obj->prev.render_op) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } if (obj->cur.scale != obj->prev.scale) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } if (o->changed) @@ -1774,64 +1924,57 @@ evas_object_text_render_pre(Evas_Object *obj) ((o->cur.glow2.a != o->prev.glow2.a))) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } } done: evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, - obj, is_v, was_v); + eo_obj, is_v, was_v); } static void -evas_object_text_render_post(Evas_Object *obj) +evas_object_text_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { - Evas_Object_Text *o; + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); /* this moves the current data to the previous state parts of the object in whatever way is safest for the object. also if we don't need object data anymore we can free it if the object deems this is a good idea */ - o = (Evas_Object_Text *)(obj->object_data); /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); o->prev = o->cur; o->changed = 0; } static unsigned int -evas_object_text_id_get(Evas_Object *obj) +evas_object_text_id_get(Evas_Object *eo_obj) { - Evas_Object_Text *o; - - o = (Evas_Object_Text *)(obj->object_data); + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_TEXT; } static unsigned int -evas_object_text_visual_id_get(Evas_Object *obj) +evas_object_text_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Text *o; - - o = (Evas_Object_Text *)(obj->object_data); + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_SHAPE; } static void * -evas_object_text_engine_data_get(Evas_Object *obj) +evas_object_text_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Text *o; - - o = (Evas_Object_Text *)(obj->object_data); + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return NULL; return o->font; } static int -evas_object_text_is_opaque(Evas_Object *obj __UNUSED__) +evas_object_text_is_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object is currently fully opaque over the entire gradient it occupies */ @@ -1839,7 +1982,7 @@ evas_object_text_is_opaque(Evas_Object *obj __UNUSED__) } static int -evas_object_text_was_opaque(Evas_Object *obj __UNUSED__) +evas_object_text_was_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object was currently fully opaque over the entire gradient it occupies */ @@ -1847,13 +1990,12 @@ evas_object_text_was_opaque(Evas_Object *obj __UNUSED__) } static void -evas_object_text_scale_update(Evas_Object *obj) +evas_object_text_scale_update(Evas_Object *eo_obj) { - Evas_Object_Text *o; + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); int size; const char *font; - o = (Evas_Object_Text *)(obj->object_data); font = eina_stringshare_add(o->cur.font); size = o->cur.size; if (o->cur.font) eina_stringshare_del(o->cur.font); @@ -1861,46 +2003,46 @@ evas_object_text_scale_update(Evas_Object *obj) o->prev.font = NULL; o->cur.size = 0; o->prev.size = 0; - evas_object_text_font_set(obj, font, size); + evas_object_text_font_set(eo_obj, font, size); } void -_evas_object_text_rehint(Evas_Object *obj) +_evas_object_text_rehint(Evas_Object *eo_obj) { - Evas_Object_Text *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); int is, was; - o = (Evas_Object_Text *)(obj->object_data); if (!o->font) return; - evas_font_load_hinting_set(obj->layer->evas, o->font, + evas_font_load_hinting_set(obj->layer->evas->evas, o->font, obj->layer->evas->hinting); - was = evas_object_is_in_output_rect(obj, + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); /* DO II */ - _evas_object_text_recalc(obj); + _evas_object_text_recalc(eo_obj); o->changed = 1; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_coords_recalc(obj); - is = evas_object_is_in_output_rect(obj, + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is || was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); - evas_object_inform_call_resize(obj); + evas_object_inform_call_resize(eo_obj); } static void -_evas_object_text_recalc(Evas_Object *obj) +_evas_object_text_recalc(Evas_Object *eo_obj) { - Evas_Object_Text *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Text *o = eo_data_get(eo_obj, MY_CLASS); Eina_Unicode *text = NULL; - o = (Evas_Object_Text *)(obj->object_data); if (o->items) _evas_object_text_items_clear(o); if (o->cur.utf8_text) @@ -1909,7 +2051,7 @@ _evas_object_text_recalc(Evas_Object *obj) if (!text) text = eina_unicode_strdup(EINA_UNICODE_EMPTY_STRING); - _evas_object_text_layout(obj, o, text); + _evas_object_text_layout(eo_obj, o, text); if (text) free(text); @@ -1918,8 +2060,8 @@ _evas_object_text_recalc(Evas_Object *obj) int w, h; int l = 0, r = 0, t = 0, b = 0; - w = _evas_object_text_horiz_advance_get(obj, o); - h = _evas_object_text_vert_advance_get(obj, o); + w = _evas_object_text_horiz_advance_get(eo_obj, o); + h = _evas_object_text_vert_advance_get(eo_obj, o); evas_text_style_pad_get(o->cur.style, &l, &r, &t, &b); obj->cur.geometry.w = w + l + r; obj->cur.geometry.h = h + t + b; @@ -1936,3 +2078,89 @@ _evas_object_text_recalc(Evas_Object *obj) } } +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_SET), _text_font_source_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_GET), _text_font_source_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_SET), _text_font_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_FONT_GET), _text_font_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_TEXT_SET), _text_text_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_SET), _text_bidi_delimiters_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_GET), _text_bidi_delimiters_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_TEXT_GET), _text_text_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_DIRECTION_GET), _text_direction_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_ASCENT_GET), _text_ascent_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_DESCENT_GET), _text_descent_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_MAX_ASCENT_GET), _text_max_ascent_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_MAX_DESCENT_GET), _text_max_descent_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_INSET_GET), _text_inset_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_HORIZ_ADVANCE_GET), _text_horiz_advance_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_VERT_ADVANCE_GET), _text_vert_advance_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_CHAR_POS_GET), _text_char_pos_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_LAST_UP_TO_POS), _text_last_up_to_pos), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_CHAR_COORDS_GET), _text_char_coords_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_STYLE_SET), _text_style_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_STYLE_GET), _text_style_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_SET), _text_shadow_color_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_GET), _text_shadow_color_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_SET), _text_glow_color_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_GET), _text_glow_color_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_SET), _text_glow2_color_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_GET), _text_glow2_color_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_SET), _text_outline_color_set), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_GET), _text_outline_color_get), + EO_OP_FUNC(EVAS_OBJ_TEXT_ID(EVAS_OBJ_TEXT_SUB_ID_STYLE_PAD_GET), _text_style_pad_get), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_SET, "Set the font (source) file to be used on a given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_FONT_SOURCE_GET, "Get the font file's path which is being used on a given text"), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_FONT_SET, "Set the font family and size on a given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_FONT_GET, "Retrieve the font family and size in use on a given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_TEXT_SET, "Sets the text string to be displayed by the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_SET, "Sets the BiDi delimiters used in the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_BIDI_DELIMITERS_GET, "Gets the BiDi delimiters used in the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_TEXT_GET, "Retrieves the text string currently being displayed by the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_DIRECTION_GET, "Retrieves the direction of the text currently being displayed in the text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_ASCENT_GET, "Get the ascent of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_DESCENT_GET, "Get the descent of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_MAX_ASCENT_GET, "Get the max ascent of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_MAX_DESCENT_GET, "Get the max descent of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_INSET_GET, "Get the inset of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_HORIZ_ADVANCE_GET, "Get the horizontal advance of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_VERT_ADVANCE_GET, "Get the vertical advance of the text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_CHAR_POS_GET, "Retrieve position and dimension information of a character within a text Evas_Object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_LAST_UP_TO_POS, "Retrieves the logical position of the last char in the text up to the pos given."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_CHAR_COORDS_GET, "? evas_object_text_char_coords_get"), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_STYLE_SET, "Sets the style to apply on the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_STYLE_GET, "Retrieves the style on use on the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_SET, "Sets the shadow color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_SHADOW_COLOR_GET, "Retrieves the shadow color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_SET, "Sets the glow color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_GLOW_COLOR_GET, "Retrieves the glow color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_SET, "Sets the 'glow 2' color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_GLOW2_COLOR_GET, "Retrieves the 'glow 2' color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_SET, "Sets the outline color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_OUTLINE_COLOR_GET, "Retrieves the outline color for the given text object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXT_SUB_ID_STYLE_PAD_GET, "Gets the text style pad of a text object."), + EO_OP_DESCRIPTION_SENTINEL +}; +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Text", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_TEXT_BASE_ID, op_desc, EVAS_OBJ_TEXT_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Text), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_text_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); + diff --git a/legacy/evas/src/lib/canvas/evas_object_textblock.c b/legacy/evas/src/lib/canvas/evas_object_textblock.c index b3ebda6b2c..0496a6f50d 100644 --- a/legacy/evas/src/lib/canvas/evas_object_textblock.c +++ b/legacy/evas/src/lib/canvas/evas_object_textblock.c @@ -65,6 +65,12 @@ #include "evas_private.h" #include +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_TEXTBLOCK_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_TEXTBLOCK_CLASS + #ifdef HAVE_LINEBREAK #include "linebreak.h" #include "wordbreak.h" @@ -501,28 +507,27 @@ struct _Evas_Object_Textblock }; /* private methods for textblock objects */ -static void evas_object_textblock_init(Evas_Object *obj); -static void *evas_object_textblock_new(void); -static void evas_object_textblock_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_textblock_free(Evas_Object *obj); -static void evas_object_textblock_render_pre(Evas_Object *obj); -static void evas_object_textblock_render_post(Evas_Object *obj); +static void evas_object_textblock_init(Evas_Object *eo_obj); +static void evas_object_textblock_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_textblock_free(Evas_Object *eo_obj); +static void evas_object_textblock_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_textblock_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_textblock_id_get(Evas_Object *obj); -static unsigned int evas_object_textblock_visual_id_get(Evas_Object *obj); -static void *evas_object_textblock_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_textblock_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_textblock_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_textblock_engine_data_get(Evas_Object *eo_obj); -static int evas_object_textblock_is_opaque(Evas_Object *obj); -static int evas_object_textblock_was_opaque(Evas_Object *obj); +static int evas_object_textblock_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_textblock_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static void evas_object_textblock_coords_recalc(Evas_Object *obj); +static void evas_object_textblock_coords_recalc(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static void evas_object_textblock_scale_update(Evas_Object *obj); +static void evas_object_textblock_scale_update(Evas_Object *eo_obj); static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_textblock_free, + NULL, evas_object_textblock_render, evas_object_textblock_render_pre, evas_object_textblock_render_post, @@ -548,27 +553,16 @@ static const Evas_Object_Func object_func = /* the actual api call to add a textblock */ #define TB_HEAD() \ - Evas_Object_Textblock *o; \ - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); \ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); \ return; \ MAGIC_CHECK_END(); \ - o = (Evas_Object_Textblock *)(obj->object_data); \ - MAGIC_CHECK(o, Evas_Object_Textblock, MAGIC_OBJ_TEXTBLOCK); \ - return; \ - MAGIC_CHECK_END(); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); #define TB_HEAD_RETURN(x) \ - Evas_Object_Textblock *o; \ - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); \ - return (x); \ - MAGIC_CHECK_END(); \ - o = (Evas_Object_Textblock *)(obj->object_data); \ - MAGIC_CHECK(o, Evas_Object_Textblock, MAGIC_OBJ_TEXTBLOCK); \ + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); \ return (x); \ MAGIC_CHECK_END(); - - static Eina_Bool _evas_textblock_cursor_is_at_the_end(const Evas_Textblock_Cursor *cur); static void _evas_textblock_node_text_remove(Evas_Object_Textblock *o, Evas_Object_Textblock_Node_Text *n); static Evas_Object_Textblock_Node_Format *_evas_textblock_cursor_node_format_before_or_at_pos_get(const Evas_Textblock_Cursor *cur); @@ -576,7 +570,7 @@ static size_t _evas_textblock_node_format_pos_get(const Evas_Object_Textblock_No static void _evas_textblock_node_format_remove(Evas_Object_Textblock *o, Evas_Object_Textblock_Node_Format *n, int visual_adjustment); static void _evas_textblock_node_format_free(Evas_Object_Textblock *o, Evas_Object_Textblock_Node_Format *n); static void _evas_textblock_node_text_free(Evas_Object_Textblock_Node_Text *n); -static void _evas_textblock_changed(Evas_Object_Textblock *o, Evas_Object *obj); +static void _evas_textblock_changed(Evas_Object_Textblock *o, Evas_Object *eo_obj); static void _evas_textblock_invalidate_all(Evas_Object_Textblock *o); static void _evas_textblock_cursors_update_offset(const Evas_Textblock_Cursor *cur, const Evas_Object_Textblock_Node_Text *n, size_t start, int offset); static void _evas_textblock_cursors_set_node(Evas_Object_Textblock *o, const Evas_Object_Textblock_Node_Text *n, Evas_Object_Textblock_Node_Text *new_node); @@ -670,11 +664,9 @@ _style_match_tag(const Evas_Textblock_Style *ts, const char *s, size_t tag_len, * @param obj The evas object, must not be NULL. */ static void -_nodes_clear(const Evas_Object *obj) +_nodes_clear(const Evas_Object *eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); while (o->text_nodes) { Evas_Object_Textblock_Node_Text *n; @@ -701,13 +693,14 @@ _nodes_clear(const Evas_Object *obj) * @param fmt the format to be cleaned, must not be NULL. */ static void -_format_unref_free(const Evas_Object *obj, Evas_Object_Textblock_Format *fmt) +_format_unref_free(const Evas_Object *eo_obj, Evas_Object_Textblock_Format *fmt) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); fmt->ref--; if (fmt->ref > 0) return; if (fmt->font.fdesc) evas_font_desc_unref(fmt->font.fdesc); if (fmt->font.source) eina_stringshare_del(fmt->font.source); - evas_font_free(obj->layer->evas, fmt->font.font); + evas_font_free(obj->layer->evas->evas, fmt->font.font); free(fmt); } @@ -719,7 +712,7 @@ _format_unref_free(const Evas_Object *obj, Evas_Object_Textblock_Format *fmt) * @param it the layout item to be freed */ static void -_item_free(const Evas_Object *obj, Evas_Object_Textblock_Line *ln, Evas_Object_Textblock_Item *it) +_item_free(const Evas_Object *eo_obj, Evas_Object_Textblock_Line *ln, Evas_Object_Textblock_Item *it) { if (it->type == EVAS_TEXTBLOCK_ITEM_TEXT) { @@ -733,7 +726,7 @@ _item_free(const Evas_Object *obj, Evas_Object_Textblock_Line *ln, Evas_Object_T if (fi->item) eina_stringshare_del(fi->item); } - _format_unref_free(obj, it->format); + _format_unref_free(eo_obj, it->format); if (ln) { ln->items = (Evas_Object_Textblock_Item *) eina_inlist_remove( @@ -918,8 +911,6 @@ static const char escape_strings[] = "•\0" "\xe2\x80\xa2\0" ; -EVAS_MEMPOOL(_mp_obj); - /** * @internal * Checks if a char is a whitespace. @@ -1241,7 +1232,7 @@ _format_clean_param(char *dst, const char *src) * @param[in] param the parameter of the command. */ static void -_format_command(Evas_Object *obj, Evas_Object_Textblock_Format *fmt, const char *cmd, const char *param) +_format_command(Evas_Object *eo_obj, Evas_Object_Textblock_Format *fmt, const char *cmd, const char *param) { int len; char *tmp_param; @@ -1628,9 +1619,7 @@ _format_command(Evas_Object *obj, Evas_Object_Textblock_Format *fmt, const char fmt->ellipsis = -1.0; else { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); o->have_ellipsis = 1; } } @@ -1764,7 +1753,7 @@ _format_parse(const char **s) * @param[in] str the string to parse.- Not NULL. */ static void -_format_fill(Evas_Object *obj, Evas_Object_Textblock_Format *fmt, const char *str) +_format_fill(Evas_Object *eo_obj, Evas_Object_Textblock_Format *fmt, const char *str) { const char *s; const char *item; @@ -1781,7 +1770,7 @@ _format_fill(Evas_Object *obj, Evas_Object_Textblock_Format *fmt, const char *st const char *key = NULL, *val = NULL; _format_param_parse(item, &key, &val); - _format_command(obj, fmt, key, val); + _format_command(eo_obj, fmt, key, val); eina_stringshare_del(key); eina_stringshare_del(val); } @@ -1801,8 +1790,9 @@ _format_fill(Evas_Object *obj, Evas_Object_Textblock_Format *fmt, const char *st * @return the copy of the format. */ static Evas_Object_Textblock_Format * -_format_dup(Evas_Object *obj, const Evas_Object_Textblock_Format *fmt) +_format_dup(Evas_Object *eo_obj, const Evas_Object_Textblock_Format *fmt) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); Evas_Object_Textblock_Format *fmt2; fmt2 = calloc(1, sizeof(Evas_Object_Textblock_Format)); @@ -1813,7 +1803,7 @@ _format_dup(Evas_Object *obj, const Evas_Object_Textblock_Format *fmt) if (fmt->font.source) fmt2->font.source = eina_stringshare_add(fmt->font.source); /* FIXME: just ref the font here... */ - fmt2->font.font = evas_font_load(obj->layer->evas, fmt2->font.fdesc, + fmt2->font.font = evas_font_load(obj->layer->evas->evas, fmt2->font.fdesc, fmt2->font.source, (int)(((double) fmt2->font.size) * obj->cur.scale)); return fmt2; } @@ -1858,7 +1848,7 @@ struct _Ctxt static void _layout_text_add_logical_item(Ctxt *c, Evas_Object_Textblock_Text_Item *ti, Eina_List *rel); static void _text_item_update_sizes(Ctxt *c, Evas_Object_Textblock_Text_Item *ti); -static void _layout_do_format(const Evas_Object *obj, Ctxt *c, Evas_Object_Textblock_Format **_fmt, Evas_Object_Textblock_Node_Format *n, int *style_pad_l, int *style_pad_r, int *style_pad_t, int *style_pad_b, Eina_Bool create_item); +static void _layout_do_format(const Evas_Object *eo_obj, Ctxt *c, Evas_Object_Textblock_Format **_fmt, Evas_Object_Textblock_Node_Format *n, int *style_pad_l, int *style_pad_r, int *style_pad_t, int *style_pad_b, Eina_Bool create_item); /** * @internal * Adjust the ascent/descent of the format and context. @@ -1868,11 +1858,12 @@ static void _layout_do_format(const Evas_Object *obj, Ctxt *c, Evas_Object_Textb * @param fmt The format to adjust - NOT NULL. */ static void -_layout_format_ascent_descent_adjust(const Evas_Object *obj, +_layout_format_ascent_descent_adjust(const Evas_Object *eo_obj, Evas_Coord *maxascent, Evas_Coord *maxdescent, Evas_Object_Textblock_Format *fmt) { int ascent, descent; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if (fmt->font.font) { @@ -2083,18 +2074,17 @@ _paragraph_clear(const Evas_Object *obj __UNUSED__, * Free the layout paragraph and all of it's lines and logical items. */ static void -_paragraph_free(const Evas_Object *obj, Evas_Object_Textblock_Paragraph *par) +_paragraph_free(const Evas_Object *eo_obj, Evas_Object_Textblock_Paragraph *par) { - Evas_Object_Textblock *o; - o = (Evas_Object_Textblock *)(obj->object_data); - _paragraph_clear(obj, par); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); + _paragraph_clear(eo_obj, par); { Eina_List *i, *i_prev; Evas_Object_Textblock_Item *it; EINA_LIST_FOREACH_SAFE(par->logical_items, i, i_prev, it) { - _item_free(obj, NULL, it); + _item_free(eo_obj, NULL, it); } eina_list_free(par->logical_items); } @@ -2119,13 +2109,13 @@ _paragraph_free(const Evas_Object *obj, Evas_Object_Textblock_Paragraph *par) * @param pars the paragraphs to clean - Not NULL. */ static void -_paragraphs_clear(const Evas_Object *obj, Evas_Object_Textblock_Paragraph *pars) +_paragraphs_clear(const Evas_Object *eo_obj, Evas_Object_Textblock_Paragraph *pars) { Evas_Object_Textblock_Paragraph *par; EINA_INLIST_FOREACH(EINA_INLIST_GET(pars), par) { - _paragraph_clear(obj, par); + _paragraph_clear(eo_obj, par); } } @@ -2139,10 +2129,9 @@ _paragraphs_clear(const Evas_Object *obj, Evas_Object_Textblock_Paragraph *pars) * @param pars the paragraphs to clean - Not NULL. */ static void -_paragraphs_free(const Evas_Object *obj, Evas_Object_Textblock_Paragraph *pars) +_paragraphs_free(const Evas_Object *eo_obj, Evas_Object_Textblock_Paragraph *pars) { - Evas_Object_Textblock *o; - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); o->num_paragraphs = 0; @@ -2152,7 +2141,7 @@ _paragraphs_free(const Evas_Object *obj, Evas_Object_Textblock_Paragraph *pars) par = (Evas_Object_Textblock_Paragraph *) pars; pars = (Evas_Object_Textblock_Paragraph *)eina_inlist_remove(EINA_INLIST_GET(pars), EINA_INLIST_GET(par)); - _paragraph_free(obj, par); + _paragraph_free(eo_obj, par); } } @@ -2432,11 +2421,12 @@ _layout_line_reorder(Evas_Object_Textblock_Line *line) /* FIXME: doc */ static void -_layout_calculate_format_item_size(const Evas_Object *obj, +_layout_calculate_format_item_size(const Evas_Object *eo_obj, const Evas_Object_Textblock_Format_Item *fi, Evas_Coord *maxascent, Evas_Coord *maxdescent, Evas_Coord *_y, Evas_Coord *_w, Evas_Coord *_h) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* Adjust sizes according to current line height/scale */ Evas_Coord w, h; const char *p, *s; @@ -2665,7 +2655,8 @@ _layout_text_cutoff_get(Ctxt *c, Evas_Object_Textblock_Format *fmt, c->marginr - c->x - ti->x_adjustment; if (x < 0) x = 0; - return c->ENFN->font_last_up_to_pos(c->ENDT, fmt->font.font, + Evas_Object_Protected_Data *obj = eo_data_get(c->obj, EVAS_OBJ_CLASS); + return ENFN->font_last_up_to_pos(ENDT, fmt->font.font, &ti->text_props, x, 0); } return -1; @@ -2772,19 +2763,19 @@ _text_item_update_sizes(Ctxt *c, Evas_Object_Textblock_Text_Item *ti) int dx = 0, minx = 0, maxx = 0, shx1, shx2; tw = th = 0; + Evas_Object_Protected_Data *obj = eo_data_get(c->obj, EVAS_OBJ_CLASS); if (fmt->font.font) - c->ENFN->font_string_size_get(c->ENDT, fmt->font.font, + ENFN->font_string_size_get(ENDT, fmt->font.font, &ti->text_props, &tw, &th); inset = 0; if (fmt->font.font) - inset = c->ENFN->font_inset_get(c->ENDT, fmt->font.font, + inset = ENFN->font_inset_get(ENDT, fmt->font.font, &ti->text_props); advw = 0; if (fmt->font.font) - advw = c->ENFN->font_h_advance_get(c->ENDT, fmt->font.font, + advw = ENFN->font_h_advance_get(ENDT, fmt->font.font, &ti->text_props); - /* These adjustments are calculated and thus heavily linked to those in * textblock_render!!! Don't change one without the other. */ @@ -2980,7 +2971,7 @@ skip: script = evas_common_language_script_type_get(str, script_len); - + Evas_Object_Protected_Data *obj = eo_data_get(c->obj, EVAS_OBJ_CLASS); while (script_len > 0) { Evas_Font_Instance *cur_fi = NULL; @@ -2991,7 +2982,7 @@ skip: if (ti->parent.format->font.font) { - run_len = c->ENFN->font_run_end_get(c->ENDT, + run_len = ENFN->font_run_end_get(ENDT, ti->parent.format->font.font, &script_fi, &cur_fi, script, str, script_len); } @@ -3002,7 +2993,7 @@ skip: if (cur_fi) { - c->ENFN->font_text_props_info_create(c->ENDT, + ENFN->font_text_props_info_create(ENDT, cur_fi, str, &ti->text_props, c->par->bidi_props, ti->parent.text_pos, run_len, EVAS_TEXT_PROPS_MODE_SHAPE); } @@ -3059,15 +3050,16 @@ _layout_format_item_add(Ctxt *c, Evas_Object_Textblock_Node_Format *n, const cha * FIXME: doc. */ static void -_format_finalize(Evas_Object *obj, Evas_Object_Textblock_Format *fmt) +_format_finalize(Evas_Object *eo_obj, Evas_Object_Textblock_Format *fmt) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); void *of; of = fmt->font.font; - fmt->font.font = evas_font_load(obj->layer->evas, fmt->font.fdesc, + fmt->font.font = evas_font_load(obj->layer->evas->evas, fmt->font.fdesc, fmt->font.source, (int)(((double) fmt->font.size) * obj->cur.scale)); - if (of) evas_font_free(obj->layer->evas, of); + if (of) evas_font_free(obj->layer->evas->evas, of); } /** @@ -3501,12 +3493,13 @@ _layout_ellipsis_item_new(Ctxt *c, const Evas_Object_Textblock_Item *cur_it) if (ellip_ti->parent.format->font.font) { + Evas_Object_Protected_Data *obj = eo_data_get(c->obj, EVAS_OBJ_CLASS); /* It's only 1 char anyway, we don't need the run end. */ - (void) c->ENFN->font_run_end_get(c->ENDT, + (void) ENFN->font_run_end_get(ENDT, ellip_ti->parent.format->font.font, &script_fi, &cur_fi, script, _ellip_str, len); - c->ENFN->font_text_props_info_create(c->ENDT, + ENFN->font_text_props_info_create(ENDT, cur_fi, _ellip_str, &ellip_ti->text_props, c->par->bidi_props, ellip_ti->parent.text_pos, len, EVAS_TEXT_PROPS_MODE_SHAPE); } @@ -4030,7 +4023,7 @@ static void _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, int *style_pad_b) { - Evas_Object *obj = c->obj; + Evas_Object *eo_obj = c->obj; Evas_Object_Textblock *o = c->o; /* Mark text nodes as dirty if format have changed. */ if (c->o->format_changed) @@ -4064,7 +4057,7 @@ _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, c->paragraphs = (Evas_Object_Textblock_Paragraph *) eina_inlist_remove(EINA_INLIST_GET(c->paragraphs), EINA_INLIST_GET(c->par)); - _paragraph_free(obj, c->par); + _paragraph_free(eo_obj, c->par); c->par = tmp_par; } @@ -4080,7 +4073,7 @@ _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, c->paragraphs = (Evas_Object_Textblock_Paragraph *) eina_inlist_remove(EINA_INLIST_GET(c->paragraphs), EINA_INLIST_GET(prev_par)); - _paragraph_free(obj, prev_par); + _paragraph_free(eo_obj, prev_par); } else { @@ -4094,7 +4087,7 @@ _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, { /* Only do this if this actually changes format */ if (fnode->format_change) - _layout_do_format(obj, c, &c->fmt, fnode, + _layout_do_format(eo_obj, c, &c->fmt, fnode, style_pad_l, style_pad_r, style_pad_t, style_pad_b, EINA_FALSE); fnode = _NODE_FORMAT(EINA_INLIST_GET(fnode)->next); @@ -4125,7 +4118,7 @@ _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, off += fnode->offset; /* No need to skip on the first run, or a non-visible one */ _layout_text_append(c, c->fmt, n, start, off, o->repch); - _layout_do_format(obj, c, &c->fmt, fnode, style_pad_l, + _layout_do_format(eo_obj, c, &c->fmt, fnode, style_pad_l, style_pad_r, style_pad_t, style_pad_b, EINA_TRUE); if ((c->have_underline2) || (c->have_underline)) { @@ -4171,7 +4164,7 @@ _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, c->paragraphs = (Evas_Object_Textblock_Paragraph *) eina_inlist_remove(EINA_INLIST_GET(c->paragraphs), EINA_INLIST_GET(c->par)); - _paragraph_free(obj, c->par); + _paragraph_free(eo_obj, c->par); c->par = tmp_par; } @@ -4193,16 +4186,16 @@ _layout_pre(Ctxt *c, int *style_pad_l, int *style_pad_r, int *style_pad_t, * @param h_ret the object's calculated h. */ static void -_layout(const Evas_Object *obj, int w, int h, int *w_ret, int *h_ret) +_layout(const Evas_Object *eo_obj, int w, int h, int *w_ret, int *h_ret) { - Evas_Object_Textblock *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); Ctxt ctxt, *c; int style_pad_l = 0, style_pad_r = 0, style_pad_t = 0, style_pad_b = 0; /* setup context */ - o = (Evas_Object_Textblock *)(obj->object_data); c = &ctxt; - c->obj = (Evas_Object *)obj; + c->obj = (Evas_Object *)eo_obj; c->o = o; c->paragraphs = c->par = NULL; c->format_stack = NULL; @@ -4358,8 +4351,8 @@ _layout(const Evas_Object *obj, int w, int h, int *w_ret, int *h_ret) o->style_pad.r = style_pad_r; o->style_pad.t = style_pad_t; o->style_pad.b = style_pad_b; - _paragraphs_clear(obj, c->paragraphs); - _layout(obj, w, h, w_ret, h_ret); + _paragraphs_clear(eo_obj, c->paragraphs); + _layout(eo_obj, w, h, w_ret, h_ret); } } @@ -4370,12 +4363,11 @@ _layout(const Evas_Object *obj, int w, int h, int *w_ret, int *h_ret) * @param obj the evas object - NOT NULL. */ static void -_relayout(const Evas_Object *obj) +_relayout(const Evas_Object *eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); - _layout(obj, obj->cur.geometry.w, obj->cur.geometry.h, + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); + _layout(eo_obj, obj->cur.geometry.w, obj->cur.geometry.h, &o->formatted.w, &o->formatted.h); o->formatted.valid = 1; o->last_w = obj->cur.geometry.w; @@ -4398,14 +4390,13 @@ _relayout(const Evas_Object *obj) * @see _find_layout_format_item_line_match() */ static void -_find_layout_item_line_match(Evas_Object *obj, Evas_Object_Textblock_Node_Text *n, int pos, Evas_Object_Textblock_Line **lnr, Evas_Object_Textblock_Item **itr) +_find_layout_item_line_match(Evas_Object *eo_obj, Evas_Object_Textblock_Node_Text *n, int pos, Evas_Object_Textblock_Line **lnr, Evas_Object_Textblock_Item **itr) { Evas_Object_Textblock_Paragraph *found_par; Evas_Object_Textblock_Line *ln; - Evas_Object_Textblock *o; + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); - o = (Evas_Object_Textblock *)(obj->object_data); - if (!o->formatted.valid) _relayout(obj); + if (!o->formatted.valid) _relayout(eo_obj); found_par = n->par; if (found_par) @@ -4457,13 +4448,11 @@ _find_layout_item_line_match(Evas_Object *obj, Evas_Object_Textblock_Node_Text * * @return the line of line number or NULL if no line found. */ static Evas_Object_Textblock_Line * -_find_layout_line_num(const Evas_Object *obj, int line) +_find_layout_line_num(const Evas_Object *eo_obj, int line) { Evas_Object_Textblock_Paragraph *par; Evas_Object_Textblock_Line *ln; - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); par = _layout_find_paragraph_by_line_no(o, line); if (par) @@ -4480,15 +4469,24 @@ _find_layout_line_num(const Evas_Object *obj, int line) EAPI Evas_Object * evas_object_textblock_add(Evas *e) { - Evas_Object *obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); - obj = evas_object_new(e); - evas_object_textblock_init(obj); - evas_object_inject(obj, e); - return obj; + Evas_Object *eo_obj = eo_add(EVAS_OBJ_TEXTBLOCK_CLASS, e); + eo_unref(eo_obj); + return eo_obj; +} + +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); + o->cursor = calloc(1, sizeof(Evas_Textblock_Cursor)); + _format_command_init(); + evas_object_textblock_init(eo_obj); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); } EAPI Evas_Textblock_Style * @@ -4517,7 +4515,7 @@ EAPI void evas_textblock_style_set(Evas_Textblock_Style *ts, const char *text) { Eina_List *l; - Evas_Object *obj; + Evas_Object *eo_obj; if (!ts) return; /* If the style wasn't really changed, abort. */ @@ -4525,13 +4523,11 @@ evas_textblock_style_set(Evas_Textblock_Style *ts, const char *text) (ts->style_text && text && !strcmp(text, ts->style_text))) return; - EINA_LIST_FOREACH(ts->objects, l, obj) + EINA_LIST_FOREACH(ts->objects, l, eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); _evas_textblock_invalidate_all(o); - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } _style_replace(ts, text); @@ -4688,7 +4684,7 @@ _textblock_format_node_from_style_tag(Evas_Object_Textblock *o, Evas_Object_Text /* textblock styles */ static void -_textblock_style_generic_set(Evas_Object *obj, Evas_Textblock_Style *ts, +_textblock_style_generic_set(Evas_Object *eo_obj, Evas_Textblock_Style *ts, Evas_Textblock_Style **obj_ts) { TB_HEAD(); @@ -4704,13 +4700,13 @@ _textblock_style_generic_set(Evas_Object *obj, Evas_Textblock_Style *ts, } old_ts = *obj_ts; - old_ts->objects = eina_list_remove(old_ts->objects, obj); + old_ts->objects = eina_list_remove(old_ts->objects, eo_obj); if ((old_ts->delete_me) && (!old_ts->objects)) evas_textblock_style_free(old_ts); } if (ts) { - ts->objects = eina_list_append(ts->objects, obj); + ts->objects = eina_list_append(ts->objects, eo_obj); } *obj_ts = ts; @@ -4752,59 +4748,112 @@ _textblock_style_generic_set(Evas_Object *obj, Evas_Textblock_Style *ts, o->format_changed = EINA_TRUE; _evas_textblock_invalidate_all(o); - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } EAPI void -evas_object_textblock_style_set(Evas_Object *obj, Evas_Textblock_Style *ts) +evas_object_textblock_style_set(Evas_Object *eo_obj, Evas_Textblock_Style *ts) { - TB_HEAD(); - _textblock_style_generic_set(obj, ts, &(o->style)); + eo_do(eo_obj, evas_obj_textblock_style_set(ts)); +} + +static void +_textblock_style_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + Evas_Textblock_Style *ts = va_arg(*list, Evas_Textblock_Style *); + _textblock_style_generic_set(eo_obj, ts, &(o->style)); } EAPI const Evas_Textblock_Style * -evas_object_textblock_style_get(const Evas_Object *obj) +evas_object_textblock_style_get(const Evas_Object *eo_obj) { - TB_HEAD_RETURN(NULL); - return o->style; + const Evas_Textblock_Style *ts = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_style_get(&ts)); + return ts; +} + +static void +_textblock_style_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const Evas_Textblock_Style **ts = va_arg(*list, const Evas_Textblock_Style **); + if (ts) *ts = o->style; } EAPI void -evas_object_textblock_style_user_push(Evas_Object *obj, Evas_Textblock_Style *ts) +evas_object_textblock_style_user_push(Evas_Object *eo_obj, Evas_Textblock_Style *ts) { - TB_HEAD(); - _textblock_style_generic_set(obj, ts, &(o->style_user)); + eo_do(eo_obj, evas_obj_textblock_style_user_push(ts)); +} + +static void +_textblock_style_user_push(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + Evas_Textblock_Style *ts = va_arg(*list, Evas_Textblock_Style *); + _textblock_style_generic_set(eo_obj, ts, &(o->style_user)); } EAPI const Evas_Textblock_Style * -evas_object_textblock_style_user_peek(const Evas_Object *obj) +evas_object_textblock_style_user_peek(const Evas_Object *eo_obj) { - TB_HEAD_RETURN(NULL); - return o->style_user; + const Evas_Textblock_Style *ts = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_style_user_peek(&ts)); + return ts; +} + +static void +_textblock_style_user_peek(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const Evas_Textblock_Style **ts = va_arg(*list, const Evas_Textblock_Style **); + if (ts) *ts = o->style_user; } EAPI void -evas_object_textblock_style_user_pop(Evas_Object *obj) +evas_object_textblock_style_user_pop(Evas_Object *eo_obj) { - TB_HEAD(); - _textblock_style_generic_set(obj, NULL, &(o->style_user)); + eo_do(eo_obj, evas_obj_textblock_style_user_pop()); +} + +static void +_textblock_style_user_pop(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Textblock *o = _pd; + _textblock_style_generic_set(eo_obj, NULL, &(o->style_user)); } EAPI void -evas_object_textblock_replace_char_set(Evas_Object *obj, const char *ch) +evas_object_textblock_replace_char_set(Evas_Object *eo_obj, const char *ch) { - TB_HEAD(); + eo_do(eo_obj, evas_obj_textblock_replace_char_set(ch)); +} + +static void +_textblock_replace_char_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + const char *ch = va_arg(*list, const char *); + if (o->repch) eina_stringshare_del(o->repch); if (ch) o->repch = eina_stringshare_add(ch); else o->repch = NULL; _evas_textblock_invalidate_all(o); - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } EAPI void -evas_object_textblock_legacy_newline_set(Evas_Object *obj, Eina_Bool mode) +evas_object_textblock_legacy_newline_set(Evas_Object *eo_obj, Eina_Bool mode) { - TB_HEAD(); + eo_do(eo_obj, evas_obj_textblock_legacy_newline_set(mode)); +} + +static void +_textblock_legacy_newline_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + Eina_Bool mode = va_arg(*list, int); if (o->legacy_newline == mode) return; @@ -4814,49 +4863,99 @@ evas_object_textblock_legacy_newline_set(Evas_Object *obj, Eina_Bool mode) } EAPI Eina_Bool -evas_object_textblock_legacy_newline_get(const Evas_Object *obj) +evas_object_textblock_legacy_newline_get(const Evas_Object *eo_obj) { - TB_HEAD_RETURN(EINA_FALSE); - return o->legacy_newline; + Eina_Bool newline = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_textblock_legacy_newline_get(&newline)); + return newline; +} + +static void +_textblock_legacy_newline_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + Eina_Bool *newline = va_arg(*list, Eina_Bool *); + if (newline) *newline = o->legacy_newline; } EAPI void -evas_object_textblock_valign_set(Evas_Object *obj, double align) +evas_object_textblock_valign_set(Evas_Object *eo_obj, double align) { - TB_HEAD(); + eo_do(eo_obj, evas_obj_textblock_valign_set(align)); +} + +static void +_textblock_valign_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + double align = va_arg(*list, double); if (align < 0.0) align = 0.0; else if (align > 1.0) align = 1.0; if (o->valign == align) return; o->valign = align; - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } EAPI double -evas_object_textblock_valign_get(const Evas_Object *obj) +evas_object_textblock_valign_get(const Evas_Object *eo_obj) { - TB_HEAD_RETURN(0.0); - return o->valign; + double valign = 0.0; + eo_do((Eo *)eo_obj, evas_obj_textblock_valign_get(&valign)); + return valign; +} + +static void +_textblock_valign_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + double *valign = va_arg(*list, double *); + if (valign) *valign = o->valign; } EAPI void -evas_object_textblock_bidi_delimiters_set(Evas_Object *obj, const char *delim) +evas_object_textblock_bidi_delimiters_set(Evas_Object *eo_obj, const char *delim) { - TB_HEAD(); + eo_do(eo_obj, evas_obj_textblock_bidi_delimiters_set(delim)); +} + +static void +_textblock_bidi_delimiters_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + const char *delim = va_arg(*list, const char *); eina_stringshare_replace(&o->bidi_delimiters, delim); } EAPI const char * -evas_object_textblock_bidi_delimiters_get(const Evas_Object *obj) +evas_object_textblock_bidi_delimiters_get(const Evas_Object *eo_obj) { - TB_HEAD_RETURN(NULL); - return o->bidi_delimiters; + const char *delim = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_bidi_delimiters_get(&delim)); + return delim; +} + +static void +_textblock_bidi_delimiters_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const char **delim = va_arg(*list, const char **); + *delim = o->bidi_delimiters; } EAPI const char * -evas_object_textblock_replace_char_get(Evas_Object *obj) +evas_object_textblock_replace_char_get(Evas_Object *eo_obj) { - TB_HEAD_RETURN(NULL); - return o->repch; + const char *repch = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_replace_char_get(&repch)); + return repch; +} + +static void +_textblock_replace_char_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const char **repch = va_arg(*list, const char **); + *repch = o->repch; } /** @@ -5073,15 +5172,22 @@ _prepend_escaped_char(Evas_Textblock_Cursor *cur, const char *s, EAPI void -evas_object_textblock_text_markup_set(Evas_Object *obj, const char *text) +evas_object_textblock_text_markup_set(Evas_Object *eo_obj, const char *text) { - TB_HEAD(); + eo_do(eo_obj, evas_obj_textblock_text_markup_set(text)); +} + +static void +_textblock_text_markup_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + const char *text = va_arg(*list, const char *); if ((text != o->markup_text) && (o->markup_text)) { free(o->markup_text); o->markup_text = NULL; } - _nodes_clear(obj); + _nodes_clear(eo_obj); if (!o->style && !o->style_user) { if (text != o->markup_text) @@ -5110,7 +5216,7 @@ EAPI void evas_object_textblock_text_markup_prepend(Evas_Textblock_Cursor *cur, const char *text) { if (!cur) return; - Evas_Object *obj = cur->obj; + Evas_Object *eo_obj = cur->obj; TB_HEAD(); if (text) { @@ -5226,7 +5332,7 @@ evas_object_textblock_text_markup_prepend(Evas_Textblock_Cursor *cur, const char p++; } } - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } @@ -5288,13 +5394,26 @@ _markup_get_text_append(Eina_Strbuf *txt, const Eina_Unicode *text) free(base); } EAPI const char * -evas_object_textblock_text_markup_get(const Evas_Object *obj) +evas_object_textblock_text_markup_get(const Evas_Object *eo_obj) +{ + const char *markup = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_text_markup_get(&markup)); + return markup; +} + +static void +_textblock_text_markup_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) { Evas_Object_Textblock_Node_Text *n; Eina_Strbuf *txt = NULL; - TB_HEAD_RETURN(NULL); - if (o->markup_text) return(o->markup_text); + const Evas_Object_Textblock *o = _pd; + const char **markup = va_arg(*list, const char **); + if (o->markup_text) + { + *markup = (o->markup_text); + return; + } txt = eina_strbuf_new(); EINA_INLIST_FOREACH(o->text_nodes, n) { @@ -5343,14 +5462,13 @@ evas_object_textblock_text_markup_get(const Evas_Object *obj) free(text_base); } - - o->markup_text = eina_strbuf_string_steal(txt); + (((Evas_Object_Textblock *)o)->markup_text) = eina_strbuf_string_steal(txt); eina_strbuf_free(txt); - return o->markup_text; + *markup = (o->markup_text); } EAPI char * -evas_textblock_text_markup_to_utf8(const Evas_Object *obj, const char *text) +evas_textblock_text_markup_to_utf8(const Evas_Object *eo_obj, const char *text) { /* FIXME: Redundant and awful, should be merged with markup_prepend */ Eina_Strbuf *sbuf; @@ -5403,10 +5521,10 @@ evas_textblock_text_markup_to_utf8(const Evas_Object *obj, const char *text) ttag[ttag_len] = 0; - if (obj) + if (eo_obj) { match = _style_match_tag( - evas_object_textblock_style_get(obj), + evas_object_textblock_style_get(eo_obj), ttag, ttag_len, &replace_len); } @@ -5490,13 +5608,13 @@ evas_textblock_text_markup_to_utf8(const Evas_Object *obj, const char *text) } EAPI char * -evas_textblock_text_utf8_to_markup(const Evas_Object *obj, const char *text) +evas_textblock_text_utf8_to_markup(const Evas_Object *eo_obj, const char *text) { Eina_Strbuf *sbuf; char *str = NULL; int ch, pos = 0, pos2 = 0; - (void) obj; + (void) eo_obj; if (!text) return NULL; @@ -5607,13 +5725,12 @@ static void _evas_textblock_cursor_nodes_merge(Evas_Textblock_Cursor *cur) { Evas_Object_Textblock_Node_Text *nnode; - Evas_Object_Textblock *o; int len; if (!cur) return; len = eina_ustrbuf_length_get(cur->node->unicode); - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); nnode = _NODE_TEXT(EINA_INLIST_GET(cur->node)->next); _evas_textblock_nodes_merge(o, cur->node); _evas_textblock_cursors_update_offset(cur, nnode, 0, len); @@ -5800,34 +5917,49 @@ _find_layout_item_match(const Evas_Textblock_Cursor *cur, Evas_Object_Textblock_ } EAPI Evas_Textblock_Cursor * -evas_object_textblock_cursor_get(const Evas_Object *obj) +evas_object_textblock_cursor_get(const Evas_Object *eo_obj) { - TB_HEAD_RETURN(NULL); - return o->cursor; + Evas_Textblock_Cursor *cursor = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_cursor_get(&cursor)); + return cursor; +} + +static void +_textblock_cursor_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + Evas_Textblock_Cursor **cursor = va_arg(*list, Evas_Textblock_Cursor **); + if (cursor) *cursor = o->cursor; } EAPI Evas_Textblock_Cursor * -evas_object_textblock_cursor_new(const Evas_Object *obj) +evas_object_textblock_cursor_new(const Evas_Object *eo_obj) { - Evas_Textblock_Cursor *cur; - - TB_HEAD_RETURN(NULL); - cur = calloc(1, sizeof(Evas_Textblock_Cursor)); - cur->obj = (Evas_Object *) obj; - cur->node = o->text_nodes; - cur->pos = 0; - - o->cursors = eina_list_append(o->cursors, cur); + Evas_Textblock_Cursor *cur = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_cursor_new(&cur)); return cur; } +static void +_textblock_cursor_new(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + Evas_Textblock_Cursor **cur = va_arg(*list, Evas_Textblock_Cursor **); + if (cur) + { + *cur = calloc(1, sizeof(Evas_Textblock_Cursor)); + (*cur)->obj = (Evas_Object *) eo_obj; + (*cur)->node = o->text_nodes; + (*cur)->pos = 0; + o->cursors = eina_list_append(o->cursors, *cur); + } +} + EAPI void evas_textblock_cursor_free(Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; - if (!cur) return; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (cur == o->cursor) return; o->cursors = eina_list_remove(o->cursors, cur); free(cur); @@ -5842,33 +5974,63 @@ evas_textblock_cursor_is_format(const Evas_Textblock_Cursor *cur) } EAPI const Eina_List * -evas_textblock_node_format_list_get(const Evas_Object *obj, const char *anchor) +evas_textblock_node_format_list_get(const Evas_Object *eo_obj, const char *anchor) { - TB_HEAD_RETURN(NULL); + const Eina_List *list = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_node_format_list_get(eo_obj, anchor, &list)); + return list; +} + +static void +_textblock_node_format_list_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const char *anchor = va_arg(*list, const char *); + const Eina_List **ret_list = va_arg(*list, const Eina_List **); if (!strcmp(anchor, "a")) - return o->anchors_a; - else if (!strcmp(anchor, "item")) - return o->anchors_item; - - return NULL; -} - -EAPI const Evas_Object_Textblock_Node_Format * -evas_textblock_node_format_first_get(const Evas_Object *obj) -{ - TB_HEAD_RETURN(NULL); - return o->format_nodes; -} - -EAPI const Evas_Object_Textblock_Node_Format * -evas_textblock_node_format_last_get(const Evas_Object *obj) -{ - TB_HEAD_RETURN(NULL); - if (o->format_nodes) { - return _NODE_FORMAT(EINA_INLIST_GET(o->format_nodes)->last); + *ret_list = o->anchors_a; + return; } - return NULL; + else if (!strcmp(anchor, "item")) + { + *ret_list = o->anchors_item; + return; + } + + *ret_list = NULL; +} + +EAPI const Evas_Object_Textblock_Node_Format * +evas_textblock_node_format_first_get(const Evas_Object *eo_obj) +{ + const Evas_Object_Textblock_Node_Format *format = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_node_format_first_get(&format)); + return format; +} + +static void +_textblock_node_format_first_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const Evas_Object_Textblock_Node_Format **format = va_arg(*list, const Evas_Object_Textblock_Node_Format **); + if (format) *format = o->format_nodes; +} + +EAPI const Evas_Object_Textblock_Node_Format * +evas_textblock_node_format_last_get(const Evas_Object *eo_obj) +{ + const Evas_Object_Textblock_Node_Format *format = NULL; + eo_do((Eo *)eo_obj, evas_obj_textblock_node_format_last_get(&format)); + return format; +} + +static void +_textblock_node_format_last_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + const Evas_Object_Textblock_Node_Format **format = va_arg(*list, const Evas_Object_Textblock_Node_Format **); + if (format) *format = o->format_nodes ? _NODE_FORMAT(EINA_INLIST_GET(o->format_nodes)->last) : NULL; } EAPI const Evas_Object_Textblock_Node_Format * @@ -5886,13 +6048,21 @@ evas_textblock_node_format_prev_get(const Evas_Object_Textblock_Node_Format *n) } EAPI void -evas_textblock_node_format_remove_pair(Evas_Object *obj, +evas_textblock_node_format_remove_pair(Evas_Object *eo_obj, Evas_Object_Textblock_Node_Format *n) { + eo_do(eo_obj, evas_obj_textblock_node_format_remove_pair(n)); +} + +static void +_textblock_node_format_remove_pair(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = _pd; + Evas_Object_Textblock_Node_Format *n = va_arg(*list, Evas_Object_Textblock_Node_Format *); + Evas_Object_Textblock_Node_Text *tnode1; Evas_Object_Textblock_Node_Format *fmt, *found_node = NULL; Eina_List *fstack = NULL; - TB_HEAD(); if (!n) return; @@ -5957,7 +6127,7 @@ found: size_t ind = _evas_textblock_node_format_pos_get(n); const char *format = n->format; Evas_Textblock_Cursor cur; - cur.obj = obj; + cur.obj = eo_obj; eina_ustrbuf_remove(n->text_node->unicode, ind, ind + 1); if (format && _IS_PARAGRAPH_SEPARATOR(o, format)) @@ -5990,15 +6160,14 @@ found: } } - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } EAPI void evas_textblock_cursor_paragraph_first(Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; if (!cur) return; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); cur->node = o->text_nodes; cur->pos = 0; @@ -6007,11 +6176,10 @@ evas_textblock_cursor_paragraph_first(Evas_Textblock_Cursor *cur) EAPI void evas_textblock_cursor_paragraph_last(Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *node; if (!cur) return; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); node = o->text_nodes; if (node) { @@ -6337,13 +6505,12 @@ evas_textblock_cursor_paragraph_char_last(Evas_Textblock_Cursor *cur) EAPI void evas_textblock_cursor_line_char_first(Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln = NULL; Evas_Object_Textblock_Item *it = NULL; if (!cur) return; TB_NULL_CHECK(cur->node); - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); _find_layout_item_match(cur, &ln, &it); @@ -6371,13 +6538,12 @@ evas_textblock_cursor_line_char_first(Evas_Textblock_Cursor *cur) EAPI void evas_textblock_cursor_line_char_last(Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln = NULL; Evas_Object_Textblock_Item *it = NULL; if (!cur) return; TB_NULL_CHECK(cur->node); - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); _find_layout_item_match(cur, &ln, &it); @@ -6473,7 +6639,7 @@ _evas_textblock_format_is_visible(Evas_Object_Textblock_Node_Format *fnode, * @param fmt the format to set according to. * @return nothing. */ -static void __UNUSED__ +static void EINA_UNUSED _evas_textblock_cursor_node_text_at_format(Evas_Textblock_Cursor *cur, Evas_Object_Textblock_Node_Format *fmt) { Evas_Object_Textblock_Node_Text *text; @@ -6859,13 +7025,12 @@ _evas_textblock_node_format_pos_get(const Evas_Object_Textblock_Node_Format *fmt EAPI int evas_textblock_cursor_pos_get(const Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *n; size_t npos = 0; if (!cur) return -1; TB_NULL_CHECK(cur->node, 0); - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); n = o->text_nodes; while (n != cur->node) { @@ -6878,12 +7043,11 @@ evas_textblock_cursor_pos_get(const Evas_Textblock_Cursor *cur) EAPI void evas_textblock_cursor_pos_set(Evas_Textblock_Cursor *cur, int _pos) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *n; size_t pos; if (!cur) return; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (_pos < 0) { @@ -6924,12 +7088,11 @@ evas_textblock_cursor_pos_set(Evas_Textblock_Cursor *cur, int _pos) EAPI Eina_Bool evas_textblock_cursor_line_set(Evas_Textblock_Cursor *cur, int line) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln; Evas_Object_Textblock_Item *it; if (!cur) return EINA_FALSE; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); ln = _find_layout_line_num(cur->obj, line); @@ -6988,7 +7151,6 @@ evas_textblock_cursor_copy(const Evas_Textblock_Cursor *cur, Evas_Textblock_Curs } - /* text controls */ /** * @internal @@ -7043,11 +7205,10 @@ static void _evas_textblock_cursor_break_paragraph(Evas_Textblock_Cursor *cur, Evas_Object_Textblock_Node_Format *fnode) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *n; if (!cur) return; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); n = _evas_textblock_node_text_new(); o->text_nodes = _NODE_TEXT(eina_inlist_append_relative( @@ -7151,8 +7312,7 @@ _evas_textblock_cursors_update_offset(const Evas_Textblock_Cursor *cur, { Eina_List *l; Evas_Textblock_Cursor *data; - Evas_Object_Textblock *o; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (cur != o->cursor) { @@ -7202,8 +7362,9 @@ _evas_textblock_cursors_update_offset(const Evas_Textblock_Cursor *cur, * @param obj the evas object. */ static void -_evas_textblock_changed(Evas_Object_Textblock *o, Evas_Object *obj) +_evas_textblock_changed(Evas_Object_Textblock *o, Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); o->formatted.valid = 0; o->native.valid = 0; o->content_changed = 1; @@ -7213,7 +7374,7 @@ _evas_textblock_changed(Evas_Object_Textblock *o, Evas_Object *obj) o->markup_text = NULL; } - evas_object_change(obj); + evas_object_change(eo_obj, obj); } static void @@ -7230,7 +7391,6 @@ _evas_textblock_invalidate_all(Evas_Object_Textblock *o) EAPI int evas_textblock_cursor_text_append(Evas_Textblock_Cursor *cur, const char *_text) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *n; Evas_Object_Textblock_Node_Format *fnode = NULL; Eina_Unicode *text; @@ -7238,7 +7398,7 @@ evas_textblock_cursor_text_append(Evas_Textblock_Cursor *cur, const char *_text) if (!cur) return 0; text = eina_unicode_utf8_to_unicode(_text, &len); - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); n = cur->node; if (n) @@ -7454,13 +7614,12 @@ _evas_textblock_cursor_is_at_the_end(const Evas_Textblock_Cursor *cur) EAPI Eina_Bool evas_textblock_cursor_format_append(Evas_Textblock_Cursor *cur, const char *format) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Format *n; Eina_Bool is_visible; if (!cur) return EINA_FALSE; if ((!format) || (format[0] == 0)) return EINA_FALSE; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); /* We should always have at least one text node */ if (!o->text_nodes) { @@ -7600,17 +7759,15 @@ evas_textblock_cursor_format_prepend(Evas_Textblock_Cursor *cur, const char *for return is_visible; } - EAPI void evas_textblock_cursor_char_delete(Evas_Textblock_Cursor *cur) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *n, *n2; const Eina_Unicode *text; int chr, ind, ppos; if (!cur || !cur->node) return; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); n = cur->node; text = eina_ustrbuf_string_get(n->unicode); @@ -7681,14 +7838,13 @@ EAPI void evas_textblock_cursor_range_delete(Evas_Textblock_Cursor *cur1, Evas_Textblock_Cursor *cur2) { Evas_Object_Textblock_Node_Format *fnode = NULL; - Evas_Object_Textblock *o; Evas_Object_Textblock_Node_Text *n1, *n2; Eina_Bool should_merge = EINA_FALSE, reset_cursor = EINA_FALSE; if (!cur1 || !cur1->node) return; if (!cur2 || !cur2->node) return; if (cur1->obj != cur2->obj) return; - o = (Evas_Object_Textblock *)(cur1->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur1->obj, MY_CLASS); if (evas_textblock_cursor_compare(cur1, cur2) > 0) { Evas_Textblock_Cursor *tc; @@ -8005,7 +8161,7 @@ _evas_textblock_cursor_range_text_plain_get(const Evas_Textblock_Cursor *cur1, c EAPI Eina_List * evas_textblock_cursor_range_formats_get(const Evas_Textblock_Cursor *cur1, const Evas_Textblock_Cursor *cur2) { - Evas_Object *obj; + Evas_Object *eo_obj; Eina_List *ret = NULL; Evas_Object_Textblock_Node_Text *n1, *n2; Evas_Object_Textblock_Node_Format *first, *last; @@ -8013,7 +8169,7 @@ evas_textblock_cursor_range_formats_get(const Evas_Textblock_Cursor *cur1, const if (!cur2 || !cur2->node) return NULL; if (cur1->obj != cur2->obj) return NULL; - obj = cur1->obj; + eo_obj = cur1->obj; TB_HEAD_RETURN(NULL); if (evas_textblock_cursor_compare(cur1, cur2) > 0) @@ -8176,9 +8332,8 @@ evas_textblock_cursor_geometry_get(const Evas_Textblock_Cursor *cur, Evas_Coord int ret = -1; const Evas_Textblock_Cursor *dir_cur; Evas_Textblock_Cursor cur2; - Evas_Object_Textblock *o; if (!cur) return -1; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); dir_cur = cur; @@ -8348,7 +8503,6 @@ evas_textblock_cursor_geometry_get(const Evas_Textblock_Cursor *cur, Evas_Coord static int _evas_textblock_cursor_char_pen_geometry_common_get(int (*query_func) (void *data, Evas_Font_Set *font, const Evas_Text_Props *intl_props, int pos, int *cx, int *cy, int *cw, int *ch), const Evas_Textblock_Cursor *cur, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln = NULL; Evas_Object_Textblock_Item *it = NULL; Evas_Object_Textblock_Text_Item *ti = NULL; @@ -8358,7 +8512,7 @@ _evas_textblock_cursor_char_pen_geometry_common_get(int (*query_func) (void *dat Eina_Bool previous_format; if (!cur) return -1; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); if (!cur->node) @@ -8399,7 +8553,8 @@ _evas_textblock_cursor_char_pen_geometry_common_get(int (*query_func) (void *dat if (pos < 0) pos = 0; if (ti->parent.format->font.font) { - query_func(cur->ENDT, + Evas_Object_Protected_Data *obj = eo_data_get(cur->obj, EVAS_OBJ_CLASS); + query_func(ENDT, ti->parent.format->font.font, &ti->text_props, pos, @@ -8464,28 +8619,29 @@ EAPI int evas_textblock_cursor_char_geometry_get(const Evas_Textblock_Cursor *cur, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { if (!cur) return -1; + Evas_Object_Protected_Data *obj = eo_data_get(cur->obj, EVAS_OBJ_CLASS); return _evas_textblock_cursor_char_pen_geometry_common_get( - cur->ENFN->font_char_coords_get, cur, cx, cy, cw, ch); + ENFN->font_char_coords_get, cur, cx, cy, cw, ch); } EAPI int evas_textblock_cursor_pen_geometry_get(const Evas_Textblock_Cursor *cur, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { if (!cur) return -1; + Evas_Object_Protected_Data *obj = eo_data_get(cur->obj, EVAS_OBJ_CLASS); return _evas_textblock_cursor_char_pen_geometry_common_get( - cur->ENFN->font_pen_coords_get, cur, cx, cy, cw, ch); + ENFN->font_pen_coords_get, cur, cx, cy, cw, ch); } EAPI int evas_textblock_cursor_line_geometry_get(const Evas_Textblock_Cursor *cur, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln = NULL; Evas_Object_Textblock_Item *it = NULL; int x, y, w, h; if (!cur) return -1; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); if (!cur->node) { @@ -8510,11 +8666,13 @@ evas_textblock_cursor_line_geometry_get(const Evas_Textblock_Cursor *cur, Evas_C EAPI Eina_Bool evas_textblock_cursor_visible_range_get(Evas_Textblock_Cursor *start, Evas_Textblock_Cursor *end) { - Evas *e; + Evas *eo_e; Evas_Coord cy, ch; - Evas_Object *obj = start->obj; + Evas_Object *eo_obj = start->obj; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); TB_HEAD_RETURN(EINA_FALSE); - e = evas_object_evas_get(obj); + eo_e = evas_object_evas_get(eo_obj); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); cy = 0 - obj->cur.geometry.y; ch = e->viewport.h; evas_textblock_cursor_line_coord_set(start, cy); @@ -8527,13 +8685,12 @@ evas_textblock_cursor_visible_range_get(Evas_Textblock_Cursor *start, Evas_Textb EAPI Eina_Bool evas_textblock_cursor_char_coord_set(Evas_Textblock_Cursor *cur, Evas_Coord x, Evas_Coord y) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Paragraph *found_par; Evas_Object_Textblock_Line *ln; Evas_Object_Textblock_Item *it = NULL; if (!cur) return EINA_FALSE; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); x += o->style_pad.l; y += o->style_pad.t; @@ -8578,6 +8735,7 @@ evas_textblock_cursor_char_coord_set(Evas_Textblock_Cursor *cur, Evas_Coord x, E return EINA_TRUE; } + Evas_Object_Protected_Data *obj = eo_data_get(cur->obj, EVAS_OBJ_CLASS); EINA_INLIST_FOREACH(ln->items, it) { if (((it->x + ln->x) <= x) && (((it->x + ln->x) + it->adv) > x)) @@ -8591,8 +8749,8 @@ evas_textblock_cursor_char_coord_set(Evas_Textblock_Cursor *cur, Evas_Coord x, E pos = -1; if (ti->parent.format->font.font) - pos = cur->ENFN->font_char_at_coords_get( - cur->ENDT, + pos = ENFN->font_char_at_coords_get( + ENDT, ti->parent.format->font.font, &ti->text_props, x - it->x - ln->x, 0, @@ -8635,12 +8793,11 @@ evas_textblock_cursor_char_coord_set(Evas_Textblock_Cursor *cur, Evas_Coord x, E EAPI int evas_textblock_cursor_line_coord_set(Evas_Textblock_Cursor *cur, Evas_Coord y) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Paragraph *found_par; Evas_Object_Textblock_Line *ln; if (!cur) return -1; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); y += o->style_pad.t; @@ -8772,6 +8929,7 @@ _evas_textblock_cursor_range_in_line_geometry_get( cur = (cur1) ? cur1 : cur2; if (!cur) return NULL; + Evas_Object_Protected_Data *obj = eo_data_get(cur->obj, EVAS_OBJ_CLASS); /* Find the first and last items */ it1 = it2 = NULL; @@ -8828,7 +8986,7 @@ _evas_textblock_cursor_range_in_line_geometry_get( ti = _ITEM_TEXT(it1); if (ti->parent.format->font.font) { - ret = cur->ENFN->font_pen_coords_get(cur->ENDT, + ret = ENFN->font_pen_coords_get(ENDT, ti->parent.format->font.font, &ti->text_props, start, @@ -8838,7 +8996,7 @@ _evas_textblock_cursor_range_in_line_geometry_get( { return NULL; } - ret = cur->ENFN->font_pen_coords_get(cur->ENDT, + ret = ENFN->font_pen_coords_get(ENDT, ti->parent.format->font.font, &ti->text_props, end, @@ -8915,7 +9073,7 @@ _evas_textblock_cursor_range_in_line_geometry_get( int ret; ti = _ITEM_TEXT(it1); - ret = cur->ENFN->font_pen_coords_get(cur->ENDT, + ret = ENFN->font_pen_coords_get(ENDT, ti->parent.format->font.font, &ti->text_props, start, @@ -8969,7 +9127,7 @@ _evas_textblock_cursor_range_in_line_geometry_get( int ret; ti = _ITEM_TEXT(it2); - ret = cur->ENFN->font_pen_coords_get(cur->ENDT, + ret = ENFN->font_pen_coords_get(ENDT, ti->parent.format->font.font, &ti->text_props, end, @@ -9016,7 +9174,6 @@ _evas_textblock_cursor_range_in_line_geometry_get( EAPI Eina_List * evas_textblock_cursor_range_geometry_get(const Evas_Textblock_Cursor *cur1, const Evas_Textblock_Cursor *cur2) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln1, *ln2; Evas_Object_Textblock_Item *it1, *it2; Eina_List *rects = NULL; @@ -9025,7 +9182,7 @@ evas_textblock_cursor_range_geometry_get(const Evas_Textblock_Cursor *cur1, cons if (!cur1 || !cur1->node) return NULL; if (!cur2 || !cur2->node) return NULL; if (cur1->obj != cur2->obj) return NULL; - o = (Evas_Object_Textblock *)(cur1->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur1->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur1->obj); if (evas_textblock_cursor_compare(cur1, cur2) > 0) { @@ -9089,14 +9246,13 @@ evas_textblock_cursor_range_geometry_get(const Evas_Textblock_Cursor *cur1, cons EAPI Eina_Bool evas_textblock_cursor_format_item_geometry_get(const Evas_Textblock_Cursor *cur, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { - Evas_Object_Textblock *o; Evas_Object_Textblock_Line *ln = NULL; Evas_Object_Textblock_Format_Item *fi; Evas_Object_Textblock_Item *it = NULL; Evas_Coord x, y, w, h; if (!cur || !evas_textblock_cursor_format_is_visible_get(cur)) return EINA_FALSE; - o = (Evas_Object_Textblock *)(cur->obj->object_data); + Evas_Object_Textblock *o = eo_data_get(cur->obj, MY_CLASS); if (!o->formatted.valid) _relayout(cur->obj); if (!evas_textblock_cursor_format_is_visible_get(cur)) return EINA_FALSE; _find_layout_item_line_match(cur->obj, cur->node, cur->pos, &ln, &it); @@ -9132,34 +9288,58 @@ evas_textblock_cursor_eol_get(const Evas_Textblock_Cursor *cur) /* general controls */ EAPI Eina_Bool -evas_object_textblock_line_number_geometry_get(const Evas_Object *obj, int line, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) +evas_object_textblock_line_number_geometry_get(const Evas_Object *eo_obj, int line, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch) { + Eina_Bool result = EINA_FALSE; + eo_do((Eo *)eo_obj, evas_obj_textblock_line_number_geometry_get(line, cx, cy, cw, ch, &result)); + return result; +} + +static void +_textblock_line_number_geometry_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +{ + int line = va_arg(*list, int); + Evas_Coord *cx = va_arg(*list, Evas_Coord *); + Evas_Coord *cy = va_arg(*list, Evas_Coord *); + Evas_Coord *cw = va_arg(*list, Evas_Coord *); + Evas_Coord *ch = va_arg(*list, Evas_Coord *); + Eina_Bool *result = va_arg(*list, Eina_Bool *); + Evas_Object_Textblock_Line *ln; - TB_HEAD_RETURN(0); - ln = _find_layout_line_num(obj, line); - if (!ln) return EINA_FALSE; + ln = _find_layout_line_num(eo_obj, line); + if (!ln) + { + if (result) *result = EINA_FALSE; + return; + } if (cx) *cx = ln->x; if (cy) *cy = ln->par->y + ln->y; if (cw) *cw = ln->w; if (ch) *ch = ln->h; - return EINA_TRUE; + if (result) *result = EINA_TRUE; } static void -_evas_object_textblock_clear_all(Evas_Object *obj) +_evas_object_textblock_clear_all(Evas_Object *eo_obj) { + eo_do(eo_obj, evas_obj_textblock_clear()); +} + +static void +_textblock_clear(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Object_Textblock *o = _pd; Eina_List *l; Evas_Textblock_Cursor *cur; - TB_HEAD(); if (o->paragraphs) { - _paragraphs_free(obj, o->paragraphs); + _paragraphs_free(eo_obj, o->paragraphs); o->paragraphs = NULL; } - _nodes_clear(obj); + _nodes_clear(eo_obj); o->cursor->node = NULL; o->cursor->pos = 0; EINA_LIST_FOREACH(o->cursors, l, cur) @@ -9169,14 +9349,14 @@ _evas_object_textblock_clear_all(Evas_Object *obj) } - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } EAPI void -evas_object_textblock_clear(Evas_Object *obj) +evas_object_textblock_clear(Evas_Object *eo_obj) { TB_HEAD(); - _evas_object_textblock_clear_all(obj); + _evas_object_textblock_clear_all(eo_obj); /* Force recreation of everything for textblock. * FIXME: We have the same thing in other places, merge it... */ @@ -9185,16 +9365,24 @@ evas_object_textblock_clear(Evas_Object *obj) } EAPI void -evas_object_textblock_size_formatted_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) +evas_object_textblock_size_formatted_get(const Evas_Object *eo_obj, Evas_Coord *w, Evas_Coord *h) { - TB_HEAD(); - if (!o->formatted.valid) _relayout(obj); + eo_do((Eo *)eo_obj, evas_obj_textblock_size_formatted_get(w, h)); +} + +static void +_textblock_size_formatted_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); + if (!o->formatted.valid) _relayout(eo_obj); if (w) *w = o->formatted.w; if (h) *h = o->formatted.h; } static void -_size_native_calc_line_finalize(const Evas_Object *obj, Eina_List *items, +_size_native_calc_line_finalize(const Evas_Object *eo_obj, Eina_List *items, Evas_Coord *ascent, Evas_Coord *descent, Evas_Coord *w) { Evas_Object_Textblock_Item *it; @@ -9208,7 +9396,7 @@ _size_native_calc_line_finalize(const Evas_Object *obj, Eina_List *items, /* If there are no text items yet, calc ascent/descent * according to the current format. */ if (*ascent + *descent == 0) - _layout_format_ascent_descent_adjust(obj, ascent, descent, + _layout_format_ascent_descent_adjust(eo_obj, ascent, descent, it->format); /* Add margins. */ @@ -9227,7 +9415,7 @@ _size_native_calc_line_finalize(const Evas_Object *obj, Eina_List *items, Evas_Object_Textblock_Format_Item *fi = _ITEM_FORMAT(it); if (!fi->formatme) goto loop_advance; - _layout_calculate_format_item_size(obj, fi, ascent, + _layout_calculate_format_item_size(eo_obj, fi, ascent, descent, &fy, &fw, &fh); } @@ -9238,7 +9426,7 @@ loop_advance: /* FIXME: doc */ static void -_size_native_calc_paragraph_size(const Evas_Object *obj, +_size_native_calc_paragraph_size(const Evas_Object *eo_obj, const Evas_Object_Textblock *o, const Evas_Object_Textblock_Paragraph *par, Evas_Coord *_w, Evas_Coord *_h) @@ -9257,7 +9445,7 @@ _size_native_calc_paragraph_size(const Evas_Object *obj, if (fi->item && (_IS_LINE_SEPARATOR(fi->item) || _IS_PARAGRAPH_SEPARATOR(o, fi->item))) { - _size_native_calc_line_finalize(obj, line_items, &ascent, + _size_native_calc_line_finalize(eo_obj, line_items, &ascent, &descent, &w); if (ascent + descent > h) @@ -9276,21 +9464,21 @@ _size_native_calc_paragraph_size(const Evas_Object *obj, /* If there are no text items yet, calc ascent/descent * according to the current format. */ if (it && (ascent + descent == 0)) - _layout_format_ascent_descent_adjust(obj, &ascent, + _layout_format_ascent_descent_adjust(eo_obj, &ascent, &descent, it->format); - _layout_calculate_format_item_size(obj, fi, &ascent, + _layout_calculate_format_item_size(eo_obj, fi, &ascent, &descent, &fy, &fw, &fh); } } else { - _layout_format_ascent_descent_adjust(obj, &ascent, + _layout_format_ascent_descent_adjust(eo_obj, &ascent, &descent, it->format); } } - _size_native_calc_line_finalize(obj, line_items, &ascent, &descent, &w); + _size_native_calc_line_finalize(eo_obj, line_items, &ascent, &descent, &w); line_items = eina_list_free(line_items); @@ -9306,20 +9494,28 @@ _size_native_calc_paragraph_size(const Evas_Object *obj, } EAPI void -evas_object_textblock_size_native_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) +evas_object_textblock_size_native_get(const Evas_Object *eo_obj, Evas_Coord *w, Evas_Coord *h) { - TB_HEAD(); + eo_do((Eo *)eo_obj, evas_obj_textblock_size_native_get(w, h)); +} + +static void +_textblock_size_native_get(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Textblock *o = (Evas_Object_Textblock *)_pd; + Evas_Coord *w = va_arg(*list, Evas_Coord *); + Evas_Coord *h = va_arg(*list, Evas_Coord *); if (!o->native.valid) { Evas_Coord wmax = 0, hmax = 0; Evas_Object_Textblock_Paragraph *par; /* We just want the layout objects to update, should probably * split that. */ - if (!o->formatted.valid) _relayout(obj); + if (!o->formatted.valid) _relayout(eo_obj); EINA_INLIST_FOREACH(o->paragraphs, par) { Evas_Coord tw, th; - _size_native_calc_paragraph_size(obj, o, par, &tw, &th); + _size_native_calc_paragraph_size(eo_obj, o, par, &tw, &th); if (tw > wmax) wmax = tw; hmax += th; @@ -9337,10 +9533,20 @@ evas_object_textblock_size_native_get(const Evas_Object *obj, Evas_Coord *w, Eva } EAPI void -evas_object_textblock_style_insets_get(const Evas_Object *obj, Evas_Coord *l, Evas_Coord *r, Evas_Coord *t, Evas_Coord *b) +evas_object_textblock_style_insets_get(const Evas_Object *eo_obj, Evas_Coord *l, Evas_Coord *r, Evas_Coord *t, Evas_Coord *b) { - TB_HEAD(); - if (!o->formatted.valid) _relayout(obj); + eo_do((Eo *)eo_obj, evas_obj_textblock_style_insets_get(l, r, t, b)); +} + +static void +_textblock_style_insets_get(Eo *eo_obj, void *_pd, va_list *list) +{ + const Evas_Object_Textblock *o = _pd; + Evas_Coord *l = va_arg(*list, Evas_Coord *); + Evas_Coord *r = va_arg(*list, Evas_Coord *); + Evas_Coord *t = va_arg(*list, Evas_Coord *); + Evas_Coord *b = va_arg(*list, Evas_Coord *); + if (!o->formatted.valid) _relayout(eo_obj); if (l) *l = o->style_pad.l; if (r) *r = o->style_pad.r; if (t) *t = o->style_pad.t; @@ -9353,16 +9559,18 @@ evas_object_textblock_style_insets_get(const Evas_Object *obj, Evas_Coord *l, Ev * evas_object_textblock_coords_recalc isn't really called when it's supposed * to. When that bug is fixed please remove this. */ static void -_workaround_object_coords_recalc(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__) +_workaround_object_coords_recalc(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *eo_obj, void *event_info EINA_UNUSED) { - evas_object_textblock_coords_recalc(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_textblock_coords_recalc(eo_obj, obj); } /* all nice and private */ static void -evas_object_textblock_init(Evas_Object *obj) +evas_object_textblock_init(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); #ifdef HAVE_LINEBREAK static Eina_Bool linebreak_init = EINA_FALSE; if (!linebreak_init) @@ -9373,8 +9581,6 @@ evas_object_textblock_init(Evas_Object *obj) } #endif - /* alloc image ob, setup methods and default values */ - obj->object_data = evas_object_textblock_new(); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -9391,43 +9597,32 @@ evas_object_textblock_init(Evas_Object *obj) obj->func = &object_func; obj->type = o_type; - o = (Evas_Object_Textblock *)(obj->object_data); - o->cursor->obj = obj; - evas_object_textblock_text_markup_set(obj, ""); + o->cursor->obj = eo_obj; + evas_object_textblock_text_markup_set(eo_obj, ""); o->legacy_newline = EINA_TRUE; - evas_object_event_callback_priority_add(obj, EVAS_CALLBACK_RESIZE, -1000, + evas_object_event_callback_priority_add(eo_obj, EVAS_CALLBACK_RESIZE, -1000, _workaround_object_coords_recalc, NULL); } -static void * -evas_object_textblock_new(void) +static void +_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { - Evas_Object_Textblock *o; - - /* alloc obj private data */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_textblock", Evas_Object_Textblock, 8, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Textblock); - if (!o) return NULL; - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Textblock); - o->magic = MAGIC_OBJ_TEXTBLOCK; - o->cursor = calloc(1, sizeof(Evas_Textblock_Cursor)); - _format_command_init(); - return o; + evas_object_textblock_free(eo_obj); + eo_do_super(eo_obj, eo_destructor()); } static void -evas_object_textblock_free(Evas_Object *obj) +evas_object_textblock_free(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); - _evas_object_textblock_clear_all(obj); - evas_object_textblock_style_set(obj, NULL); - while (evas_object_textblock_style_user_peek(obj)) + _evas_object_textblock_clear_all(eo_obj); + evas_object_textblock_style_set(eo_obj, NULL); + while (evas_object_textblock_style_user_peek(eo_obj)) { - evas_object_textblock_style_user_pop(obj); + evas_object_textblock_style_user_pop(eo_obj); } - o = (Evas_Object_Textblock *)(obj->object_data); free(o->cursor); while (o->cursors) { @@ -9438,19 +9633,18 @@ evas_object_textblock_free(Evas_Object *obj) free(cur); } if (o->repch) eina_stringshare_del(o->repch); - if (o->ellip_ti) _item_free(obj, NULL, _ITEM(o->ellip_ti)); + if (o->ellip_ti) _item_free(eo_obj, NULL, _ITEM(o->ellip_ti)); o->magic = 0; - EVAS_MEMPOOL_FREE(_mp_obj, o); _format_command_shutdown(); } static void -evas_object_textblock_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_textblock_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { Evas_Object_Textblock_Paragraph *par, *start = NULL; Evas_Object_Textblock_Line *ln; - Evas_Object_Textblock *o; + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); int i, j; int cx, cy, cw, ch, clip; const char vals[5][5] = @@ -9463,7 +9657,6 @@ evas_object_textblock_render(Evas_Object *obj, void *output, void *context, void }; /* render object to surface with context, and offxet by x,y */ - o = (Evas_Object_Textblock *)(obj->object_data); obj->layer->evas->engine.func->context_multiplier_unset(output, context); /* FIXME: This clipping is just until we fix inset handling correctly. */ @@ -9841,9 +10034,9 @@ evas_object_textblock_render(Evas_Object *obj, void *output, void *context, void } static void -evas_object_textblock_render_pre(Evas_Object *obj) +evas_object_textblock_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Textblock *o; + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); int is_v, was_v; /* dont pre-render the obj twice! */ @@ -9854,57 +10047,57 @@ evas_object_textblock_render_pre(Evas_Object *obj) /* elsewhere, decoding video etc. */ /* then when this is done the object needs to figure if it changed and */ /* if so what and where and add the appropriate redraw textblocks */ - o = (Evas_Object_Textblock *)(obj->object_data); if ((o->changed) || (o->content_changed) || (o->format_changed) || ((obj->cur.geometry.w != o->last_w) || (((o->valign != 0.0) || (o->have_ellipsis)) && (obj->cur.geometry.h != o->last_h)))) { - _relayout(obj); + _relayout(eo_obj); o->redraw = 0; - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); goto done; } if (o->redraw) { o->redraw = 0; - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); goto done; } /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper_obj = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + evas_object_clip_recalc(obj->cur.clipper, cur_clipper_obj); + cur_clipper_obj->func->render_pre(obj->cur.clipper, cur_clipper_obj); } /* now figure what changed and add draw rects */ /* if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); if (is_v != was_v) { - evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); goto done; } if (obj->changed_map) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, + eo_obj, obj); goto done; } /* it's not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj); /* if we restacked (layer or just within a layer) and don't clip anyone */ if (obj->restack) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed color */ @@ -9913,7 +10106,7 @@ evas_object_textblock_render_pre(Evas_Object *obj) (obj->cur.color.b != obj->prev.color.b) || (obj->cur.color.a != obj->prev.color.a)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed geometry - and obviously not visibility or color */ @@ -9924,15 +10117,15 @@ evas_object_textblock_render_pre(Evas_Object *obj) (obj->cur.geometry.w != obj->prev.geometry.w) || (obj->cur.geometry.h != obj->prev.geometry.h)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } done: - evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); } static void -evas_object_textblock_render_post(Evas_Object *obj) +evas_object_textblock_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* Evas_Object_Textblock *o; */ @@ -9941,42 +10134,36 @@ evas_object_textblock_render_post(Evas_Object *obj) /* data anymore we can free it if the object deems this is a good idea */ /* o = (Evas_Object_Textblock *)(obj->object_data); */ /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); /* o->prev = o->cur; */ /* o->changed = 0; */ } -static unsigned int evas_object_textblock_id_get(Evas_Object *obj) +static unsigned int evas_object_textblock_id_get(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_TEXTBLOCK; } -static unsigned int evas_object_textblock_visual_id_get(Evas_Object *obj) +static unsigned int evas_object_textblock_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_CUSTOM; } -static void *evas_object_textblock_engine_data_get(Evas_Object *obj) +static void *evas_object_textblock_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return NULL; return o->engine_data; } static int -evas_object_textblock_is_opaque(Evas_Object *obj __UNUSED__) +evas_object_textblock_is_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object is */ /* currently fulyl opque over the entire gradient it occupies */ @@ -9984,7 +10171,7 @@ evas_object_textblock_is_opaque(Evas_Object *obj __UNUSED__) } static int -evas_object_textblock_was_opaque(Evas_Object *obj __UNUSED__) +evas_object_textblock_was_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object was */ /* currently fulyl opque over the entire gradient it occupies */ @@ -9992,11 +10179,9 @@ evas_object_textblock_was_opaque(Evas_Object *obj __UNUSED__) } static void -evas_object_textblock_coords_recalc(Evas_Object *obj) +evas_object_textblock_coords_recalc(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); if ((obj->cur.geometry.w != o->last_w) || (((o->valign != 0.0) || (o->have_ellipsis)) && (obj->cur.geometry.h != o->last_h))) @@ -10007,25 +10192,23 @@ evas_object_textblock_coords_recalc(Evas_Object *obj) } static void -evas_object_textblock_scale_update(Evas_Object *obj) +evas_object_textblock_scale_update(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; - - o = (Evas_Object_Textblock *)(obj->object_data); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); _evas_textblock_invalidate_all(o); - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); o->last_w = -1; o->last_h = -1; } void -_evas_object_textblock_rehint(Evas_Object *obj) +_evas_object_textblock_rehint(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); Evas_Object_Textblock_Paragraph *par; Evas_Object_Textblock_Line *ln; - o = (Evas_Object_Textblock *)(obj->object_data); EINA_INLIST_FOREACH(o->paragraphs, par) { EINA_INLIST_FOREACH(par->lines, ln) @@ -10038,8 +10221,8 @@ _evas_object_textblock_rehint(Evas_Object *obj) { Evas_Object_Textblock_Text_Item *ti = _ITEM_TEXT(it); if (ti->parent.format->font.font) - { - evas_font_load_hinting_set(obj->layer->evas, + { + evas_font_load_hinting_set(obj->layer->evas->evas, ti->parent.format->font.font, obj->layer->evas->hinting); } @@ -10048,7 +10231,7 @@ _evas_object_textblock_rehint(Evas_Object *obj) } } _evas_textblock_invalidate_all(o); - _evas_textblock_changed(o, obj); + _evas_textblock_changed(o, eo_obj); } /** @@ -10058,17 +10241,16 @@ _evas_object_textblock_rehint(Evas_Object *obj) #ifdef HAVE_TESTS /* return EINA_FALSE on error, used in unit_testing */ EAPI Eina_Bool -_evas_textblock_check_item_node_link(Evas_Object *obj) +_evas_textblock_check_item_node_link(Evas_Object *eo_obj) { - Evas_Object_Textblock *o; + Evas_Object_Textblock *o = eo_data_get(eo_obj, MY_CLASS); Evas_Object_Textblock_Paragraph *par; Evas_Object_Textblock_Line *ln; Evas_Object_Textblock_Item *it; - o = (Evas_Object_Textblock *)(obj->object_data); if (!o) return EINA_FALSE; - if (!o->formatted.valid) _relayout(obj); + if (!o->formatted.valid) _relayout(eo_obj); EINA_INLIST_FOREACH(o->paragraphs, par) { @@ -10091,6 +10273,83 @@ _evas_textblock_format_offset_get(const Evas_Object_Textblock_Node_Format *n) } #endif +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_SET), _textblock_style_set), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_GET), _textblock_style_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PUSH), _textblock_style_user_push), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PEEK), _textblock_style_user_peek), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_POP), _textblock_style_user_pop), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_SET), _textblock_replace_char_set), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_SET), _textblock_legacy_newline_set), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_GET), _textblock_legacy_newline_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_SET), _textblock_valign_set), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_GET), _textblock_valign_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_SET), _textblock_bidi_delimiters_set), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_GET), _textblock_bidi_delimiters_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_GET), _textblock_replace_char_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_SET), _textblock_text_markup_set), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_GET), _textblock_text_markup_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_GET), _textblock_cursor_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_NEW), _textblock_cursor_new), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LIST_GET), _textblock_node_format_list_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_FIRST_GET), _textblock_node_format_first_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LAST_GET), _textblock_node_format_last_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_REMOVE_PAIR), _textblock_node_format_remove_pair), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_LINE_NUMBER_GEOMETRY_GET), _textblock_line_number_geometry_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_CLEAR), _textblock_clear), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_FORMATTED_GET), _textblock_size_formatted_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_NATIVE_GET), _textblock_size_native_get), + EO_OP_FUNC(EVAS_OBJ_TEXTBLOCK_ID(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_INSETS_GET), _textblock_style_insets_get), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_SET, "Set the objects style to ts."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_GET, "Return the style of an object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PUSH, "Push ts to the top of the user style stack."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_PEEK, "Get (don't remove) the style at the top of the user style stack."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_USER_POP, "Del the from the top of the user style stack."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_SET, "Set the replacement character to use for the given textblock object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_SET, "Sets newline mode."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_LEGACY_NEWLINE_GET, "Gets newline mode."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_SET, "Sets the vertical alignment of text within the textblock object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_VALIGN_GET, "Gets the vertical alignment of a textblock."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_SET, "Sets the BiDi delimiters used in the textblock."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_BIDI_DELIMITERS_GET, "Gets the BiDi delimiters used in the textblock."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_REPLACE_CHAR_GET, "Get the replacement character for given textblock object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_SET, "Sets the tetxblock's text to the markup text."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_TEXT_MARKUP_GET, "Return the markup of the object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_GET, "Return the object's main cursor."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_CURSOR_NEW, "Create a new cursor."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LIST_GET, "Returns the list format node."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_FIRST_GET, "Returns the first format node."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_LAST_GET, "Returns the last format node."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_NODE_FORMAT_REMOVE_PAIR, "Removes a format node and its match."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_LINE_NUMBER_GEOMETRY_GET, "Get the geometry of a line number."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_CLEAR, "Clear the textblock object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_FORMATTED_GET, "Get the formatted width and height."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_SIZE_NATIVE_GET, "Get the native width and height."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTBLOCK_SUB_ID_STYLE_INSETS_GET, "? evas_object_textblock_style_insets_get"), + EO_OP_DESCRIPTION_SENTINEL +}; +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Evas_Object_Textblock", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_TEXTBLOCK_BASE_ID, op_desc, EVAS_OBJ_TEXTBLOCK_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Textblock), + _class_constructor, + NULL +}; +EO_DEFINE_CLASS(evas_object_textblock_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); + #if 0 /* Good for debugging */ void diff --git a/legacy/evas/src/lib/canvas/evas_object_textgrid.c b/legacy/evas/src/lib/canvas/evas_object_textgrid.c index f04751873b..78fa7322a0 100644 --- a/legacy/evas/src/lib/canvas/evas_object_textgrid.c +++ b/legacy/evas/src/lib/canvas/evas_object_textgrid.c @@ -1,6 +1,12 @@ #include "evas_common.h" /* Includes evas_bidi_utils stuff. */ #include "evas_private.h" +#include "Eo.h" + +EAPI Eo_Op EVAS_OBJ_TEXTGRID_BASE_ID = EO_NOOP; + +#define MY_CLASS EVAS_OBJ_TEXTGRID_CLASS + /* save typing */ #define ENFN obj->layer->evas->engine.func #define ENDT obj->layer->evas->engine.data.output @@ -107,26 +113,24 @@ struct _Evas_Object_Textgrid_Line }; /* private methods for textgrid objects */ -static void evas_object_textgrid_init(Evas_Object *obj); -static void *evas_object_textgrid_new(void); -static void evas_object_textgrid_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); -static void evas_object_textgrid_free(Evas_Object *obj); -static void evas_object_textgrid_render_pre(Evas_Object *obj); -static void evas_object_textgrid_render_post(Evas_Object *obj); +static void evas_object_textgrid_init(Evas_Object *eo_obj); +static void evas_object_textgrid_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y); +static void evas_object_textgrid_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static void evas_object_textgrid_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static unsigned int evas_object_textgrid_id_get(Evas_Object *obj); -static unsigned int evas_object_textgrid_visual_id_get(Evas_Object *obj); -static void *evas_object_textgrid_engine_data_get(Evas_Object *obj); +static unsigned int evas_object_textgrid_id_get(Evas_Object *eo_obj); +static unsigned int evas_object_textgrid_visual_id_get(Evas_Object *eo_obj); +static void *evas_object_textgrid_engine_data_get(Evas_Object *eo_obj); -static int evas_object_textgrid_is_opaque(Evas_Object *obj); -static int evas_object_textgrid_was_opaque(Evas_Object *obj); +static int evas_object_textgrid_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); +static int evas_object_textgrid_was_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj); -static void evas_object_textgrid_scale_update(Evas_Object *obj); +static void evas_object_textgrid_scale_update(Evas_Object *eo_obj); static const Evas_Object_Func object_func = { /* methods (compulsory) */ - evas_object_textgrid_free, + NULL, evas_object_textgrid_render, evas_object_textgrid_render_pre, evas_object_textgrid_render_post, @@ -149,11 +153,9 @@ static const Evas_Object_Func object_func = NULL }; -EVAS_MEMPOOL(_mp_obj); - /* almost generic private array data type */ static int -evas_object_textgrid_textprop_get(Evas_Object *obj, Evas_Object_Textgrid *o, Eina_Unicode codepoint, +evas_object_textgrid_textprop_get(Evas_Object *eo_obj, Evas_Object_Textgrid *o, Eina_Unicode codepoint, unsigned int glyphs_index, unsigned char *used) { Evas_Textgrid_Hash_Glyphs *glyph; @@ -168,6 +170,7 @@ evas_object_textgrid_textprop_get(Evas_Object *obj, Evas_Object_Textgrid *o, Ein Evas_Script_Type script; script = evas_common_language_script_type_get(&codepoint, 1); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); ENFN->font_run_end_get(ENDT, o->font, &script_fi, &cur_fi, script, &codepoint, 1); memset(&(glyph->props[idx]), 0, sizeof(Evas_Text_Props)); evas_common_text_props_script_set(&(glyph->props[idx]), script); @@ -185,7 +188,7 @@ evas_object_textgrid_textprop_get(Evas_Object *obj, Evas_Object_Textgrid *o, Ein } static int -evas_object_textgrid_textprop_ref(Evas_Object *obj, Evas_Object_Textgrid *o, Eina_Unicode codepoint) +evas_object_textgrid_textprop_ref(Evas_Object *eo_obj, Evas_Object_Textgrid *o, Eina_Unicode codepoint) { unsigned int mask = 0xF0000000; unsigned int shift = 28; @@ -305,7 +308,7 @@ evas_object_textgrid_textprop_ref(Evas_Object *obj, Evas_Object_Textgrid *o, Ein end: glyphs_index = o->last_glyphs - o->glyphs; - return evas_object_textgrid_textprop_get(obj, o, codepoint, glyphs_index, + return evas_object_textgrid_textprop_get(eo_obj, o, codepoint, glyphs_index, &(o->glyphs_used[glyphs_index])); } @@ -334,10 +337,9 @@ evas_object_textgrid_textprop_int_to(Evas_Object_Textgrid *o, int props) /* all nice and private */ static void -evas_object_textgrid_init(Evas_Object *obj) +evas_object_textgrid_init(Evas_Object *eo_obj) { - /* alloc textgrid ob, setup methods and default values */ - obj->object_data = evas_object_textgrid_new(); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); /* set up default settings for this kind of object */ obj->cur.color.r = 255; obj->cur.color.g = 255; @@ -353,23 +355,13 @@ evas_object_textgrid_init(Evas_Object *obj) /* set up methods (compulsory) */ obj->func = &object_func; obj->type = o_type; -} -static void * -evas_object_textgrid_new(void) -{ - Evas_Object_Textgrid *o; - - /* FIXME: using evas mempool like text ? */ - EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_textgrid", Evas_Object_Textgrid, 4, NULL); - o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Textgrid); - EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Textgrid); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); o->magic = MAGIC_OBJ_TEXTGRID; o->prev = o->cur; eina_array_step_set(&o->cur.palette_standard, sizeof (Eina_Array), 16); eina_array_step_set(&o->cur.palette_extended, sizeof (Eina_Array), 16); eina_array_step_set(&o->glyphs_cleanup, sizeof (Eina_Array), 16); - return o; } static void @@ -407,12 +399,11 @@ evas_object_textgrid_row_clear(Evas_Object_Textgrid *o, Evas_Object_Textgrid_Row } static void -evas_object_textgrid_rows_clear(Evas_Object *obj) +evas_object_textgrid_rows_clear(Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; int i; - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); if (!o->cur.rows) return; for (i = 0; i < o->cur.h; i++) { @@ -423,24 +414,18 @@ evas_object_textgrid_rows_clear(Evas_Object *obj) } static void -evas_object_textgrid_free(Evas_Object *obj) +evas_object_textgrid_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { Evas_Object_Textgrid_Color *c; - Evas_Object_Textgrid *o; - - /* frees private object data. very simple here */ - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); /* free obj */ - evas_object_textgrid_rows_clear(obj); + evas_object_textgrid_rows_clear(eo_obj); if (o->cur.rows) free(o->cur.rows); if (o->cur.font_name) eina_stringshare_del(o->cur.font_name); if (o->cur.font_source) eina_stringshare_del(o->cur.font_source); if (o->cur.font_description) evas_font_desc_unref(o->cur.font_description); - if (o->font) evas_font_free(obj->layer->evas, o->font); + if (o->font) evas_font_free(obj->layer->evas->evas, o->font); if (o->cur.cells) free(o->cur.cells); while ((c = eina_array_pop(&o->cur.palette_standard))) free(c); @@ -476,10 +461,15 @@ evas_object_textgrid_free(Evas_Object *obj) free(o->glyphs_used); o->magic = 0; - /* FIXME: using evas mempool like text ? */ - EVAS_MEMPOOL_FREE(_mp_obj, o); } +static void +_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_textgrid_free(eo_obj, obj); + eo_do_super(eo_obj, eo_destructor()); +} static void evas_object_textgrid_row_rect_append(Evas_Object_Textgrid_Row *row, int x, int w, int r, int g, int b, int a) @@ -507,7 +497,7 @@ evas_object_textgrid_row_rect_append(Evas_Object_Textgrid_Row *row, int x, int w } static void -evas_object_textgrid_row_text_append(Evas_Object_Textgrid_Row *row, Evas_Object *obj, Evas_Object_Textgrid *o, int x, Eina_Unicode codepoint, int r, int g, int b, int a) +evas_object_textgrid_row_text_append(Evas_Object_Textgrid_Row *row, Evas_Object *eo_obj, Evas_Object_Textgrid *o, int x, Eina_Unicode codepoint, int r, int g, int b, int a) { row->texts_num++; if (row->texts_num > row->texts_alloc) @@ -524,7 +514,7 @@ evas_object_textgrid_row_text_append(Evas_Object_Textgrid_Row *row, Evas_Object row->texts = t; } - row->texts[row->texts_num - 1].text_props = evas_object_textgrid_textprop_ref(obj, o, codepoint); + row->texts[row->texts_num - 1].text_props = evas_object_textgrid_textprop_ref(eo_obj, o, codepoint); row->texts[row->texts_num - 1].x = x; row->texts[row->texts_num - 1].r = r; row->texts[row->texts_num - 1].g = g; @@ -559,9 +549,8 @@ evas_object_textgrid_row_line_append(Evas_Object_Textgrid_Row *row, int x, int w } static void -evas_object_textgrid_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) +evas_object_textgrid_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *output, void *context, void *surface, int x, int y) { - Evas_Object_Textgrid *o; Evas_Textgrid_Cell *cells; Evas_Object_Textgrid_Color *c; Eina_Array *palette; @@ -569,7 +558,7 @@ evas_object_textgrid_render(Evas_Object *obj, void *output, void *context, void int rr = 0, rg = 0, rb = 0, ra = 0, rx = 0, rw = 0, run; /* render object to surface with context, and offxet by x,y */ - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); ENFN->context_multiplier_unset(output, context); ENFN->context_render_op_set(output, context, obj->cur.render_op); @@ -640,7 +629,7 @@ evas_object_textgrid_render(Evas_Object *obj, void *output, void *context, void else c = eina_array_data_get(palette, cells->fg); if ((c) && (c->a > 0)) { - evas_object_textgrid_row_text_append(row, obj, o, xp, + evas_object_textgrid_row_text_append(row, eo_obj, o, xp, cells->codepoint, c->r, c->g, c->b, c->a); // XXX: underlines and strikethroughs dont get @@ -704,9 +693,8 @@ evas_object_textgrid_render(Evas_Object *obj, void *output, void *context, void } static void -evas_object_textgrid_render_pre(Evas_Object *obj) +evas_object_textgrid_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Textgrid *o; int is_v, was_v; /* dont pre-render the obj twice! */ @@ -717,37 +705,38 @@ evas_object_textgrid_render_pre(Evas_Object *obj) /* elsewhere, decoding video etc. */ /* then when this is done the object needs to figure if it changed and */ /* if so what and where and add thr appropriate redraw rectangles */ - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); /* if someone is clipping this obj - go calculate the clipper */ if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); if (obj->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); - obj->cur.clipper->func->render_pre(obj->cur.clipper); + evas_object_clip_recalc(obj->cur.clipper, cur_clipper); + cur_clipper->func->render_pre(obj->cur.clipper, cur_clipper); } /* now figure what changed and add draw rects */ /* if it just became visible or invisible */ - is_v = evas_object_is_visible(obj); - was_v = evas_object_was_visible(obj); + is_v = evas_object_is_visible(eo_obj, obj); + was_v = evas_object_was_visible(eo_obj, obj); if (is_v != was_v) { - evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); goto done; } if (obj->changed_map) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } /* its not visible - we accounted for it appearing or not so just abort */ if (!is_v) goto done; /* clipper changed this is in addition to anything else for obj */ - evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj); /* if we restacked (layer or just within a layer) and dont clip anyone */ if (obj->restack) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed color */ @@ -756,7 +745,7 @@ evas_object_textgrid_render_pre(Evas_Object *obj) (obj->cur.color.b != obj->prev.color.b) || (obj->cur.color.a != obj->prev.color.a)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } /* if it changed geometry - and obviously not visibility or color */ @@ -767,17 +756,17 @@ evas_object_textgrid_render_pre(Evas_Object *obj) (obj->cur.geometry.w != obj->prev.geometry.w) || (obj->cur.geometry.h != obj->prev.geometry.h)) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } if (obj->cur.render_op != obj->prev.render_op) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } if (obj->cur.scale != obj->prev.scale) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } @@ -794,13 +783,13 @@ evas_object_textgrid_render_pre(Evas_Object *obj) ((!o->cur.font_name) && (o->prev.font_name))) { evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, - obj); + eo_obj, obj); goto done; } } if (o->pal_change) { - evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); + evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj); goto done; } if (o->row_change) @@ -826,22 +815,20 @@ evas_object_textgrid_render_pre(Evas_Object *obj) o->core_change = 0; o->row_change = 0; o->pal_change = 0; - evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, obj, is_v, was_v); + evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v); } static void -evas_object_textgrid_render_post(Evas_Object *obj) +evas_object_textgrid_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED) { - Evas_Object_Textgrid *o; - /* this moves the current data to the previous state parts of the object */ /* in whatever way is safest for the object. also if we don't need object */ /* data anymore we can free it if the object deems this is a good idea */ - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); /* remove those pesky changes */ - evas_object_clip_changes_clean(obj); + evas_object_clip_changes_clean(eo_obj); /* move cur to prev safely for object data */ - evas_object_cur_prev(obj); + evas_object_cur_prev(eo_obj); o->prev = o->cur; o->changed = 0; @@ -867,37 +854,31 @@ evas_object_textgrid_render_post(Evas_Object *obj) } static unsigned int -evas_object_textgrid_id_get(Evas_Object *obj) +evas_object_textgrid_id_get(Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; - - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_TEXTGRID; } static unsigned int -evas_object_textgrid_visual_id_get(Evas_Object *obj) +evas_object_textgrid_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; - - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_SHAPE; } static void * -evas_object_textgrid_engine_data_get(Evas_Object *obj) +evas_object_textgrid_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; - - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); if (!o) return NULL; return o->font; } static int -evas_object_textgrid_is_opaque(Evas_Object *obj __UNUSED__) +evas_object_textgrid_is_opaque(Evas_Object *eo_obj __UNUSED__, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object is currently fully opaque over the entire gradient it occupies */ @@ -905,7 +886,7 @@ evas_object_textgrid_is_opaque(Evas_Object *obj __UNUSED__) } static int -evas_object_textgrid_was_opaque(Evas_Object *obj __UNUSED__) +evas_object_textgrid_was_opaque(Evas_Object *eo_obj __UNUSED__, Evas_Object_Protected_Data *obj EINA_UNUSED) { /* this returns 1 if the internal object data implies that the object was currently fully opaque over the entire gradient it occupies */ @@ -913,13 +894,12 @@ evas_object_textgrid_was_opaque(Evas_Object *obj __UNUSED__) } static void -evas_object_textgrid_scale_update(Evas_Object *obj) +evas_object_textgrid_scale_update(Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; int font_size; const char *font_name; - o = (Evas_Object_Textgrid *)(obj->object_data); + Evas_Object_Textgrid *o = eo_data_get(eo_obj, MY_CLASS); font_name = eina_stringshare_add(o->cur.font_name); font_size = o->cur.font_size; if (o->cur.font_name) eina_stringshare_del(o->cur.font_name); @@ -927,7 +907,7 @@ evas_object_textgrid_scale_update(Evas_Object *obj) o->prev.font_name = NULL; o->cur.font_size = 0; o->prev.font_size = 0; - evas_object_textgrid_font_set(obj, font_name, font_size); + evas_object_textgrid_font_set(eo_obj, font_name, font_size); } /********************* LOCAL *********************/ @@ -937,37 +917,47 @@ evas_object_textgrid_scale_update(Evas_Object *obj) EAPI Evas_Object * evas_object_textgrid_add(Evas *e) { - Evas_Object *obj; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Evas_Object *eo_obj = eo_add(EVAS_OBJ_TEXTGRID_CLASS, e); + eo_unref(eo_obj); + return eo_obj; +} - obj = evas_object_new(e); - evas_object_textgrid_init(obj); - evas_object_inject(obj, e); - return obj; +static void +_constructor(Eo *eo_obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(eo_obj, eo_constructor()); + + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_textgrid_init(eo_obj); + evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent_get(eo_obj))); } EAPI void -evas_object_textgrid_size_set(Evas_Object *obj, int w, int h) +evas_object_textgrid_size_set(Evas_Object *eo_obj, int w, int h) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_size_set(w, h)); +} + +static void +_size_set(Eo *eo_obj, void *_pd, va_list *list) +{ + int w = va_arg(*list, int); + int h = va_arg(*list, int); int i; if ((h <= 0) || (w <= 0)) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + Evas_Object_Textgrid *o = _pd; if ((o->cur.w == w) && (o->cur.h == h)) return; - evas_object_textgrid_rows_clear(obj); + evas_object_textgrid_rows_clear(eo_obj); if (o->cur.rows) { free(o->cur.rows); @@ -996,44 +986,53 @@ evas_object_textgrid_size_set(Evas_Object *obj, int w, int h) o->cur.h = h; o->changed = 1; o->core_change = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_textgrid_size_get(const Evas_Object *obj, int *w, int *h) +evas_object_textgrid_size_get(const Evas_Object *eo_obj, int *w, int *h) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_textgrid_size_get(w, h)); +} + +static void +_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); + if (h) *h = 0; if (w) *w = 0; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + const Evas_Object_Textgrid *o = _pd; if (w) *w = o->cur.w; if (h) *h = o->cur.h; } EAPI void -evas_object_textgrid_font_source_set(Evas_Object *obj, const char *font_source) +evas_object_textgrid_font_source_set(Evas_Object *eo_obj, const char *font_source) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_font_source_set(font_source)); +} + +static void +_font_source_set(Eo *eo_obj, void *_pd, va_list *list) +{ + const char *font_source = va_arg(*list, const char *); if ((!font_source) || (!*font_source)) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + Evas_Object_Textgrid *o = _pd; if ((o->cur.font_source) && (font_source) && (!strcmp(o->cur.font_source, font_source))) return; @@ -1041,42 +1040,51 @@ evas_object_textgrid_font_source_set(Evas_Object *obj, const char *font_source) eina_stringshare_replace(&o->cur.font_source, font_source); o->changed = 1; o->core_change = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI const char * -evas_object_textgrid_font_source_get(const Evas_Object *obj) +evas_object_textgrid_font_source_get(const Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + const char *ret = NULL; + eo_do((Eo *)eo_obj, evas_obj_textgrid_font_source_get(&ret)); + return ret; +} - return o->cur.font_source; +static void +_font_source_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const char **ret = va_arg(*list, const char **); + const Evas_Object_Textgrid *o = _pd; + *ret = o->cur.font_source; } EAPI void -evas_object_textgrid_font_set(Evas_Object *obj, const char *font_name, Evas_Font_Size font_size) +evas_object_textgrid_font_set(Evas_Object *eo_obj, const char *font_name, Evas_Font_Size font_size) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_font_set(font_name, font_size)); +} + +static void +_font_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + const char *font_name = va_arg(*list, const char *); + Evas_Font_Size font_size = va_arg(*list, Evas_Font_Size); int is, was = 0, pass = 0, freeze = 0; Evas_Font_Description *font_description; if ((!font_name) || (!*font_name) || (font_size <= 0)) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + Evas_Object_Textgrid *o = _pd; font_description = evas_font_desc_new(); evas_font_name_parse(font_description, font_name); @@ -1095,12 +1103,12 @@ evas_object_textgrid_font_set(Evas_Object *obj, const char *font_name, Evas_Font eina_stringshare_replace(&o->cur.font_name, font_name); o->prev.font_name = NULL; - if (obj->layer->evas->events_frozen <= 0) + if (!(obj->layer->evas->is_frozen)) { - pass = evas_event_passes_through(obj); - freeze = evas_event_freezes_through(obj); + pass = evas_event_passes_through(eo_obj, obj); + freeze = evas_event_freezes_through(eo_obj, obj); if ((!pass) && (!freeze)) - was = evas_object_is_in_output_rect(obj, + was = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); @@ -1109,11 +1117,11 @@ evas_object_textgrid_font_set(Evas_Object *obj, const char *font_name, Evas_Font /* DO IT */ if (o->font) { - evas_font_free(obj->layer->evas, o->font); + evas_font_free(obj->layer->evas->evas, o->font); o->font = NULL; } - o->font = evas_font_load(obj->layer->evas, o->cur.font_description, + o->font = evas_font_load(obj->layer->evas->evas, o->cur.font_description, o->cur.font_source, (int)(((double) o->cur.font_size) * obj->cur.scale)); @@ -1152,30 +1160,30 @@ evas_object_textgrid_font_set(Evas_Object *obj, const char *font_name, Evas_Font } o->changed = 1; - evas_object_change(obj); - evas_object_clip_dirty(obj); - evas_object_coords_recalc(obj); - if (obj->layer->evas->events_frozen <= 0) + evas_object_change(eo_obj, obj); + evas_object_clip_dirty(eo_obj, obj); + evas_object_coords_recalc(eo_obj, obj); + if (!(obj->layer->evas->is_frozen)) { if ((!pass) && (!freeze)) { - is = evas_object_is_in_output_rect(obj, + is = evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1); if ((is ^ was) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, NULL); } } - evas_object_inform_call_resize(obj); + evas_object_inform_call_resize(eo_obj); o->changed = 1; o->core_change = 1; - evas_object_textgrid_rows_clear(obj); - evas_object_change(obj); + evas_object_textgrid_rows_clear(eo_obj); + evas_object_change(eo_obj, obj); /* Force destroy of all cached Evas_Text_Props */ while (eina_array_count(&o->glyphs_cleanup) > 0) @@ -1200,64 +1208,74 @@ evas_object_textgrid_font_set(Evas_Object *obj, const char *font_name, Evas_Font } EAPI void -evas_object_textgrid_font_get(const Evas_Object *obj, const char **font_name, Evas_Font_Size *font_size) +evas_object_textgrid_font_get(const Evas_Object *eo_obj, const char **font_name, Evas_Font_Size *font_size) { - Evas_Object_Textgrid *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (font_name) *font_name = ""; - if (font_size) *font_size = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); if (font_name) *font_name = ""; if (font_size) *font_size = 0; return; MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_textgrid_font_get(font_name, font_size)); +} +static void +_font_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const char **font_name = va_arg(*list, const char **); + Evas_Font_Size *font_size = va_arg(*list, Evas_Font_Size *); + const Evas_Object_Textgrid *o = _pd; if (font_name) *font_name = o->cur.font_name; if (font_size) *font_size = o->cur.font_size; } EAPI void -evas_object_textgrid_cell_size_get(const Evas_Object *obj, Evas_Coord *w, Evas_Coord *h) +evas_object_textgrid_cell_size_get(const Evas_Object *eo_obj, Evas_Coord *w, Evas_Coord *h) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (w) *w = 0; + if (h) *h = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_textgrid_cell_size_get(w, h)); +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); +static void +_cell_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *w = va_arg(*list, int *); + int *h = va_arg(*list, int *); + const Evas_Object_Textgrid *o = _pd; if (w) *w = o->cur.char_width; if (h) *h = o->cur.char_height; } EAPI void -evas_object_textgrid_palette_set(Evas_Object *obj, Evas_Textgrid_Palette pal, int idx, int r, int g, int b, int a) +evas_object_textgrid_palette_set(Evas_Object *eo_obj, Evas_Textgrid_Palette pal, int idx, int r, int g, int b, int a) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_palette_set(pal, idx, r, g, b, a)); +} + +static void +_palette_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Textgrid_Palette pal = va_arg(*list, Evas_Textgrid_Palette); + int idx = va_arg(*list, int); + int r = va_arg(*list, int); + int g = va_arg(*list, int); + int b = va_arg(*list, int); + int a = va_arg(*list, int); + Eina_Array *palette; Evas_Object_Textgrid_Color *color, *c; int count, i; if ((idx < 0) || (idx > 255)) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + Evas_Object_Textgrid *o = _pd; if (a > 255) a = 255; if (a < 0) a = 0; if (r > 255) r = 255; if (r < 0) r = 0; @@ -1330,42 +1348,47 @@ evas_object_textgrid_palette_set(Evas_Object *obj, Evas_Textgrid_Palette pal, in } o->changed = 1; o->pal_change = 1; - evas_object_textgrid_rows_clear(obj); - evas_object_change(obj); + evas_object_textgrid_rows_clear(eo_obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } EAPI void -evas_object_textgrid_palette_get(const Evas_Object *obj, Evas_Textgrid_Palette pal, int idx, int *r, int *g, int *b, int *a) +evas_object_textgrid_palette_get(const Evas_Object *eo_obj, Evas_Textgrid_Palette pal, int idx, int *r, int *g, int *b, int *a) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + if (a) *a = 0; + if (r) *r = 0; + if (g) *g = 0; + if (b) *b = 0; + return; + MAGIC_CHECK_END(); + eo_do((Eo *)eo_obj, evas_obj_textgrid_palette_get(pal, idx, r, g, b, a)); +} + +static void +_palette_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Textgrid_Palette pal = va_arg(*list, Evas_Textgrid_Palette); + int idx = va_arg(*list, int); + int *r = va_arg(*list, int *); + int *g = va_arg(*list, int *); + int *b = va_arg(*list, int *); + int *a = va_arg(*list, int *); Eina_Array *palette; Evas_Object_Textgrid_Color *color; if (idx < 0) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - if (a) *a = 0; - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - if (a) *a = 0; - if (r) *r = 0; - if (g) *g = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); + const Evas_Object_Textgrid *o = _pd; switch (pal) { case EVAS_TEXTGRID_PALETTE_STANDARD: - palette = &(o->cur.palette_standard); + palette = &(((Evas_Object_Textgrid *)o)->cur.palette_standard); break; case EVAS_TEXTGRID_PALETTE_EXTENDED: - palette = &(o->cur.palette_extended); + palette = &(((Evas_Object_Textgrid *)o)->cur.palette_extended); break; default: return; @@ -1383,92 +1406,110 @@ evas_object_textgrid_palette_get(const Evas_Object *obj, Evas_Textgrid_Palette p EAPI void -evas_object_textgrid_supported_font_styles_set(Evas_Object *obj, Evas_Textgrid_Font_Style styles) +evas_object_textgrid_supported_font_styles_set(Evas_Object *eo_obj, Evas_Textgrid_Font_Style styles) { - Evas_Object_Textgrid *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_supported_font_styles_set(styles)); +} + +static void +_supported_font_styles_set(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Textgrid_Font_Style styles = va_arg(*list, Evas_Textgrid_Font_Style); + Evas_Object_Textgrid *o = _pd; /* FIXME: to do */ if (styles) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); o->changed = 1; - evas_object_change(obj); + evas_object_change(eo_obj, obj); } } EAPI Evas_Textgrid_Font_Style -evas_object_textgrid_supported_font_styles_get(const Evas_Object *obj) +evas_object_textgrid_supported_font_styles_get(const Evas_Object *eo_obj) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return EVAS_TEXTGRID_FONT_STYLE_NORMAL; + MAGIC_CHECK_END(); + Evas_Textgrid_Font_Style ret = EVAS_TEXTGRID_FONT_STYLE_NORMAL; + eo_do((Eo *)eo_obj, evas_obj_textgrid_supported_font_styles_get(&ret)); + return ret; +} - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return EVAS_TEXTGRID_FONT_STYLE_NORMAL; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return EVAS_TEXTGRID_FONT_STYLE_NORMAL; - MAGIC_CHECK_END(); +static void +_supported_font_styles_get(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + Evas_Textgrid_Font_Style *ret = va_arg(*list, Evas_Textgrid_Font_Style *); /* FIXME: to do */ - return 0; + *ret = 0; } EAPI void -evas_object_textgrid_cellrow_set(Evas_Object *obj, int y, const Evas_Textgrid_Cell *row) +evas_object_textgrid_cellrow_set(Evas_Object *eo_obj, int y, const Evas_Textgrid_Cell *row) { - Evas_Object_Textgrid *o; - + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_cellrow_set(y, row)); +} + +static void +_cellrow_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int y = va_arg(*list, int); + const Evas_Textgrid_Cell *row = va_arg(*list, const Evas_Textgrid_Cell *); if (!row) return; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); - + Evas_Object_Textgrid *o = _pd; if ((y < 0) || (y >= o->cur.h)) return; } EAPI Evas_Textgrid_Cell * -evas_object_textgrid_cellrow_get(const Evas_Object *obj, int y) +evas_object_textgrid_cellrow_get(const Evas_Object *eo_obj, int y) { - Evas_Object_Textgrid *o; - - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Textgrid_Cell *ret = NULL; + eo_do((Eo *)eo_obj, evas_obj_textgrid_cellrow_get(y, &ret)); + return ret; +} - if ((y < 0) || (y >= o->cur.h)) return NULL; +static void +_cellrow_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + int y = va_arg(*list, int); + Evas_Textgrid_Cell **ret = va_arg(*list, Evas_Textgrid_Cell **); + const Evas_Object_Textgrid *o = _pd; + if ((y < 0) || (y >= o->cur.h)) *ret = NULL; - return o->cur.cells + (y * o->cur.w); + *ret = o->cur.cells + (y * o->cur.w); } EAPI void -evas_object_textgrid_update_add(Evas_Object *obj, int x, int y, int w, int h) +evas_object_textgrid_update_add(Evas_Object *eo_obj, int x, int y, int w, int h) { - Evas_Object_Textgrid *o; + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); + return; + MAGIC_CHECK_END(); + eo_do(eo_obj, evas_obj_textgrid_update_add(x, y, w, h)); +} + +static void +_update_add(Eo *eo_obj, void *_pd, va_list *list) +{ + int x = va_arg(*list, int); + int y = va_arg(*list, int); + int w = va_arg(*list, int); + int h = va_arg(*list, int); int i, x2; - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - o = (Evas_Object_Textgrid *)(obj->object_data); - MAGIC_CHECK(o, Evas_Object_Textgrid, MAGIC_OBJ_TEXTGRID); - return; - MAGIC_CHECK_END(); + Evas_Object_Textgrid *o = _pd; RECTS_CLIP_TO_RECT(x, y, w, h, 0, 0, o->cur.w, o->cur.h); if ((w <= 0) || (h <= 0)) return; @@ -1492,5 +1533,62 @@ evas_object_textgrid_update_add(Evas_Object *obj, int x, int y, int w, int h) } o->row_change = 1; o->changed = 1; - evas_object_change(obj); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + evas_object_change(eo_obj, obj); } + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_SET), _size_set), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_GET), _size_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_SET), _font_source_set), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_GET), _font_source_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SET), _font_set), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_GET), _font_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_CELL_SIZE_GET), _cell_size_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_SET), _palette_set), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_GET), _palette_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_SET), _supported_font_styles_set), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_GET), _supported_font_styles_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_SET), _cellrow_set), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_GET), _cellrow_get), + EO_OP_FUNC(EVAS_OBJ_TEXTGRID_ID(EVAS_OBJ_TEXTGRID_SUB_ID_UPDATE_ADD), _update_add), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_SET, "Set the size of the textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_SIZE_GET, "Get the size of the textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_SET, "Set the font (source) file to be used on a given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SOURCE_GET, "Get the font file's path which is being used on a given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_SET, "Set the font family and size on a given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_FONT_GET, "Retrieve the font family and size in use on a given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_CELL_SIZE_GET, "Retrieve the size of a cell of the given textgrid object in pixels."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_SET, "The set color to the given palette at the given index of the given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_PALETTE_GET, "The retrieve color to the given palette at the given index of the given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_SET, "Set the supported font styles."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_SUPPORTED_FONT_STYLES_GET, "Get the supported font styles."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_SET, "Set the string at the given row of the given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_CELLROW_GET, "Get the string at the given row of the given textgrid object."), + EO_OP_DESCRIPTION(EVAS_OBJ_TEXTGRID_SUB_ID_UPDATE_ADD, "Indicate for evas that part of a textgrid region (cells) has been updated."), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "evas_object_textgrid", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_TEXTGRID_BASE_ID, op_desc, EVAS_OBJ_TEXTGRID_SUB_ID_LAST), + NULL, + sizeof(Evas_Object_Textgrid), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(evas_object_textgrid_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); diff --git a/legacy/evas/src/lib/canvas/evas_render.c b/legacy/evas/src/lib/canvas/evas_render.c index 21efd0eacc..6409699666 100644 --- a/legacy/evas/src/lib/canvas/evas_render.c +++ b/legacy/evas/src/lib/canvas/evas_render.c @@ -50,16 +50,28 @@ rend_dbg(const char *txt) #endif static Eina_List * -evas_render_updates_internal(Evas *e, unsigned char make_updates, unsigned char do_draw); +evas_render_updates_internal(Evas *eo_e, unsigned char make_updates, unsigned char do_draw); EAPI void -evas_damage_rectangle_add(Evas *e, int x, int y, int w, int h) +evas_damage_rectangle_add(Evas *eo_e, int x, int y, int w, int h) { - Eina_Rectangle *r; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_damage_rectangle_add(x, y, w, h)); +} + +void +_canvas_damage_rectangle_add(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int x = va_arg(*list, int); + int y = va_arg(*list, int); + int w = va_arg(*list, int); + int h = va_arg(*list, int); + + Eina_Rectangle *r; + + Evas_Public_Data *e = _pd; NEW_RECT(r, x, y, w, h); if (!r) return; e->damages = eina_list_append(e->damages, r); @@ -67,26 +79,45 @@ evas_damage_rectangle_add(Evas *e, int x, int y, int w, int h) } EAPI void -evas_obscured_rectangle_add(Evas *e, int x, int y, int w, int h) +evas_obscured_rectangle_add(Evas *eo_e, int x, int y, int w, int h) { - Eina_Rectangle *r; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_obscured_rectangle_add(x, y, w, h)); +} + +void +_canvas_obscured_rectangle_add(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + int x = va_arg(*list, int); + int y = va_arg(*list, int); + int w = va_arg(*list, int); + int h = va_arg(*list, int); + + Eina_Rectangle *r; + + Evas_Public_Data *e = _pd; NEW_RECT(r, x, y, w, h); if (!r) return; e->obscures = eina_list_append(e->obscures, r); } EAPI void -evas_obscured_clear(Evas *e) +evas_obscured_clear(Evas *eo_e) +{ + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_obscured_clear()); +} + +void +_canvas_obscured_clear(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) { Eina_Rectangle *r; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); + Evas_Public_Data *e = _pd; EINA_LIST_FREE(e->obscures, r) { eina_rectangle_free(r); @@ -94,28 +125,33 @@ evas_obscured_clear(Evas *e) } static Eina_Bool -_evas_render_had_map(Evas_Object *obj) +_evas_render_had_map(Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); return ((obj->prev.map) && (obj->prev.usemap)); // return ((!obj->cur.map) && (obj->prev.usemap)); } static Eina_Bool -_evas_render_is_relevant(Evas_Object *obj) +_evas_render_is_relevant(Evas_Object *eo_obj) { - return ((evas_object_is_visible(obj) && (!obj->cur.have_clipees)) || - (evas_object_was_visible(obj) && (!obj->prev.have_clipees))); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + return ((evas_object_is_visible(eo_obj, obj) && (!obj->cur.have_clipees)) || + (evas_object_was_visible(eo_obj, obj) && (!obj->prev.have_clipees))); } static Eina_Bool -_evas_render_can_render(Evas_Object *obj) +_evas_render_can_render(Evas_Object *eo_obj) { - return (evas_object_is_visible(obj) && (!obj->cur.have_clipees)); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + return (evas_object_is_visible(eo_obj, obj) && (!obj->cur.have_clipees)); } static void -_evas_render_prev_cur_clip_cache_add(Evas *e, Evas_Object *obj) +_evas_render_prev_cur_clip_cache_add(Evas *eo_e, Evas_Object *eo_obj) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); e->engine.func->output_redraws_rect_add(e->engine.data.output, obj->prev.cache.clip.x, obj->prev.cache.clip.y, @@ -129,8 +165,10 @@ _evas_render_prev_cur_clip_cache_add(Evas *e, Evas_Object *obj) } static void -_evas_render_cur_clip_cache_del(Evas *e, Evas_Object *obj) +_evas_render_cur_clip_cache_del(Evas *eo_e, Evas_Object *eo_obj) { + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Coord x, y, w, h; x = obj->cur.cache.clip.x; @@ -139,89 +177,96 @@ _evas_render_cur_clip_cache_del(Evas *e, Evas_Object *obj) h = obj->cur.cache.clip.h; if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); RECTS_CLIP_TO_RECT(x, y, w, h, - obj->cur.clipper->cur.cache.clip.x, - obj->cur.clipper->cur.cache.clip.y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x, + cur_clipper->cur.cache.clip.y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); } e->engine.func->output_redraws_rect_del(e->engine.data.output, x, y, w, h); } static void -_evas_render_phase1_direct(Evas *e, +_evas_render_phase1_direct(Evas *eo_e, Eina_Array *active_objects, - Eina_Array *restack_objects __UNUSED__, - Eina_Array *delete_objects __UNUSED__, + Eina_Array *restack_objects EINA_UNUSED, + Eina_Array *delete_objects EINA_UNUSED, Eina_Array *render_objects) { unsigned int i; Eina_List *l; - Evas_Object *proxy; + Evas_Object *eo_proxy; RD(" [--- PHASE 1 DIRECT\n"); for (i = 0; i < active_objects->count; i++) { - Evas_Object *obj; + Evas_Object *eo_obj; - obj = eina_array_data_get(active_objects, i); + Evas_Object_Protected_Data *obj = eina_array_data_get(active_objects, i); + eo_obj = obj->object; if (obj->changed) { /* Flag need redraw on proxy too */ - evas_object_clip_recalc(obj); - EINA_LIST_FOREACH(obj->proxy.proxies, l, proxy) - proxy->proxy.redraw = EINA_TRUE; + evas_object_clip_recalc(eo_obj, obj); + EINA_LIST_FOREACH(obj->proxy.proxies, l, eo_proxy) + { + Evas_Object_Protected_Data *proxy = eo_data_get(eo_proxy, EVAS_OBJ_CLASS); + proxy->proxy.redraw = EINA_TRUE; + } } } for (i = 0; i < render_objects->count; i++) { - Evas_Object *obj; + Evas_Object *eo_obj; - obj = eina_array_data_get(render_objects, i); + Evas_Object_Protected_Data *obj = eina_array_data_get(render_objects, i); + eo_obj = obj->object; RD(" OBJ [%p] changed %i\n", obj, obj->changed); if (obj->changed) { /* Flag need redraw on proxy too */ - evas_object_clip_recalc(obj); - obj->func->render_pre(obj); + evas_object_clip_recalc(eo_obj, obj); + obj->func->render_pre(eo_obj, obj); if (obj->proxy.redraw) - _evas_render_prev_cur_clip_cache_add(e, obj); + _evas_render_prev_cur_clip_cache_add(eo_e, eo_obj); if (obj->proxy.proxies) { obj->proxy.redraw = EINA_TRUE; - EINA_LIST_FOREACH(obj->proxy.proxies, l, proxy) + EINA_LIST_FOREACH(obj->proxy.proxies, l, eo_proxy) { - proxy->func->render_pre(proxy); - _evas_render_prev_cur_clip_cache_add(e, proxy); + Evas_Object_Protected_Data *proxy = eo_data_get(eo_proxy, EVAS_OBJ_CLASS); + proxy->func->render_pre(eo_proxy, proxy); + _evas_render_prev_cur_clip_cache_add(eo_e, eo_proxy); } } RD(" pre-render-done smart:%p|%p [%p, %i] | [%p, %i] has_map:%i had_map:%i\n", obj->smart.smart, - evas_object_smart_members_get_direct(obj), + evas_object_smart_members_get_direct(eo_obj), obj->cur.map, obj->cur.usemap, obj->prev.map, obj->prev.usemap, - _evas_render_has_map(obj), - _evas_render_had_map(obj)); - if ((obj->smart.smart) && - (_evas_render_has_map(obj))) + _evas_render_has_map(eo_obj), + _evas_render_had_map(eo_obj)); + if ((obj->is_smart) && + (_evas_render_has_map(eo_obj))) { RD(" has map + smart\n"); - _evas_render_prev_cur_clip_cache_add(e, obj); + _evas_render_prev_cur_clip_cache_add(eo_e, eo_obj); } } else { - if (obj->smart.smart) + if (obj->is_smart) { - // obj->func->render_pre(obj); + // obj->func->render_pre(eo_obj); } else if ((obj->rect_del) || - (evas_object_is_opaque(obj) && evas_object_is_visible(obj))) + (evas_object_is_opaque(eo_obj, obj) && evas_object_is_visible(eo_obj, obj))) { RD(" rect del\n"); - _evas_render_cur_clip_cache_del(e, obj); + _evas_render_cur_clip_cache_del(eo_e, eo_obj); } } } @@ -229,7 +274,7 @@ _evas_render_phase1_direct(Evas *e, } static Eina_Bool -_evas_render_phase1_object_process(Evas *e, Evas_Object *obj, +_evas_render_phase1_object_process(Evas *eo_e, Evas_Object *eo_obj, Eina_Array *active_objects, Eina_Array *restack_objects, Eina_Array *delete_objects, @@ -242,11 +287,12 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, #endif ) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Eina_Bool clean_them = EINA_FALSE; - Evas_Object *obj2; int is_active; Eina_Bool map, hmap; + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); //Need pre render for the children of mapped object. //But only when they have changed. if (mapped_parent && (!obj->changed)) return EINA_FALSE; @@ -255,14 +301,14 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, obj->render_pre = EINA_FALSE; if (obj->delete_me == 2) - eina_array_push(delete_objects, obj); + eina_array_push(delete_objects, obj); else if (obj->delete_me != 0) obj->delete_me++; /* If the object will be removed, we should not cache anything during this run. */ if (obj->delete_me != 0) clean_them = EINA_TRUE; /* build active object list */ - evas_object_clip_recalc(obj); - is_active = evas_object_is_active(obj); + evas_object_clip_recalc(eo_obj, obj); + is_active = evas_object_is_active(eo_obj, obj); obj->is_active = is_active; RDI(level); @@ -279,8 +325,8 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, } #endif - map = _evas_render_has_map(obj); - hmap = _evas_render_had_map(obj); + map = _evas_render_has_map(eo_obj); + hmap = _evas_render_had_map(eo_obj); if ((restack) && (!map)) { @@ -302,18 +348,19 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, if (map != hmap) *redraw_all = 1; if ((is_active) && (!obj->clip.clipees) && - ((evas_object_is_visible(obj) && (!obj->cur.have_clipees)) || - (evas_object_was_visible(obj) && (!obj->prev.have_clipees)))) + ((evas_object_is_visible(eo_obj, obj) && (!obj->cur.have_clipees)) || + (evas_object_was_visible(eo_obj, obj) && (!obj->prev.have_clipees)))) { eina_array_push(render_objects, obj); - _evas_render_prev_cur_clip_cache_add(e, obj); + _evas_render_prev_cur_clip_cache_add(eo_e, eo_obj); obj->render_pre = EINA_TRUE; - if (obj->smart.smart) + if (obj->is_smart) { - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), obj2) + Evas_Object_Protected_Data *obj2; + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2) { - _evas_render_phase1_object_process(e, obj2, + _evas_render_phase1_object_process(eo_e, obj2->object, active_objects, restack_objects, delete_objects, @@ -336,7 +383,7 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, RDI(level); RD(" had map - restack objs\n"); // eina_array_push(restack_objects, obj); - _evas_render_prev_cur_clip_cache_add(e, obj); + _evas_render_prev_cur_clip_cache_add(eo_e, eo_obj); if (obj->changed) { if (!map) @@ -353,16 +400,17 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, /* handle normal rendering. this object knows how to handle maps */ if (obj->changed) { - if (obj->smart.smart) + if (obj->is_smart) { RDI(level); RD(" changed + smart - render ok\n"); eina_array_push(render_objects, obj); obj->render_pre = EINA_TRUE; - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), + Evas_Object_Protected_Data *obj2; + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2) { - _evas_render_phase1_object_process(e, obj2, + _evas_render_phase1_object_process(eo_e, obj2->object, active_objects, restack_objects, delete_objects, @@ -379,7 +427,7 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, else { if ((is_active) && (!obj->clip.clipees) && - _evas_render_is_relevant(obj)) + _evas_render_is_relevant(eo_obj)) { RDI(level); RD(" relevant + active\n"); @@ -401,24 +449,25 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, else { RD(" not changed... [%i] -> (%i %i %p %i) [%i]\n", - evas_object_is_visible(obj), + evas_object_is_visible(eo_obj, obj), obj->cur.visible, obj->cur.cache.clip.visible, obj->smart.smart, - obj->cur.cache.clip.a, evas_object_was_visible(obj)); + obj->cur.cache.clip.a, evas_object_was_visible(eo_obj, obj)); if ((!obj->clip.clipees) && (obj->delete_me == 0) && - (_evas_render_can_render(obj) || - (evas_object_was_visible(obj) && (!obj->prev.have_clipees)))) + (_evas_render_can_render(eo_obj) || + (evas_object_was_visible(eo_obj, obj) && (!obj->prev.have_clipees)))) { - if (obj->smart.smart) + if (obj->is_smart) { RDI(level); RD(" smart + visible/was visible + not clip\n"); eina_array_push(render_objects, obj); obj->render_pre = EINA_TRUE; + Evas_Object_Protected_Data *obj2; EINA_INLIST_FOREACH - (evas_object_smart_members_get_direct(obj), obj2) + (evas_object_smart_members_get_direct(eo_obj), obj2) { - _evas_render_phase1_object_process(e, obj2, + _evas_render_phase1_object_process(eo_e, obj2->object, active_objects, restack_objects, delete_objects, @@ -434,15 +483,15 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, } else { - if (evas_object_is_opaque(obj) && - evas_object_is_visible(obj)) + if (evas_object_is_opaque(eo_obj, obj) && + evas_object_is_visible(eo_obj, obj)) { RDI(level); RD(" opaque + visible\n"); eina_array_push(render_objects, obj); obj->rect_del = EINA_TRUE; } - else if (evas_object_is_visible(obj)) + else if (evas_object_is_visible(eo_obj, obj)) { RDI(level); RD(" visible\n"); @@ -462,10 +511,10 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, RD(" smart + mot visible/was visible\n"); eina_array_push(render_objects, obj); obj->render_pre = 1; - EINA_INLIST_FOREACH (evas_object_smart_members_get_direct(obj), + EINA_INLIST_FOREACH (evas_object_smart_members_get_direct(eo_obj), obj2) { - _evas_render_phase1_object_process(e, obj2, + _evas_render_phase1_object_process(eo_e, obj2, active_objects, restack_objects, delete_objects, @@ -487,25 +536,26 @@ _evas_render_phase1_object_process(Evas *e, Evas_Object *obj, } static Eina_Bool -_evas_render_phase1_process(Evas *e, +_evas_render_phase1_process(Evas *eo_e, Eina_Array *active_objects, Eina_Array *restack_objects, Eina_Array *delete_objects, Eina_Array *render_objects, int *redraw_all) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Layer *lay; Eina_Bool clean_them = EINA_FALSE; RD(" [--- PHASE 1\n"); EINA_INLIST_FOREACH(e->layers, lay) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_FOREACH(lay->objects, obj) { clean_them |= _evas_render_phase1_object_process - (e, obj, active_objects, restack_objects, delete_objects, + (eo_e, obj->object, active_objects, restack_objects, delete_objects, render_objects, 0, redraw_all, EINA_FALSE #ifdef REND_DBG , 1 @@ -518,24 +568,27 @@ _evas_render_phase1_process(Evas *e, } static void -_evas_render_check_pending_objects(Eina_Array *pending_objects, Evas *e) +_evas_render_check_pending_objects(Eina_Array *pending_objects, Evas *eo_e EINA_UNUSED, Evas_Public_Data *e) { unsigned int i; for (i = 0; i < pending_objects->count; ++i) { - Evas_Object *obj; + Evas_Object *eo_obj; int is_active; Eina_Bool ok = EINA_FALSE; - obj = eina_array_data_get(pending_objects, i); + + Evas_Object_Protected_Data *obj = eina_array_data_get(pending_objects, i); + eo_obj = obj->object; + if (!obj->layer) goto clean_stuff; //If the children are in active objects, They should be cleaned up. - if (obj->changed_map && _evas_render_has_map(obj)) + if (obj->changed_map && _evas_render_has_map(eo_obj)) goto clean_stuff; - evas_object_clip_recalc(obj); - is_active = evas_object_is_active(obj); + evas_object_clip_recalc(eo_obj, obj); + is_active = evas_object_is_active(eo_obj, obj); if ((!is_active) && (!obj->is_active) && (!obj->render_pre) && (!obj->rect_del)) @@ -548,22 +601,22 @@ _evas_render_check_pending_objects(Eina_Array *pending_objects, Evas *e) { if (obj->changed) { - if (obj->smart.smart) + if (obj->is_smart) { if (obj->render_pre || obj->rect_del) ok = EINA_TRUE; } else if ((is_active) && (obj->restack) && (!obj->clip.clipees) && - (_evas_render_can_render(obj) || - (evas_object_was_visible(obj) && (!obj->prev.have_clipees)))) + (_evas_render_can_render(eo_obj) || + (evas_object_was_visible(eo_obj, obj) && (!obj->prev.have_clipees)))) { if (!(obj->render_pre || obj->rect_del)) ok = EINA_TRUE; } else if (is_active && (!obj->clip.clipees) && - (_evas_render_can_render(obj) || - (evas_object_was_visible(obj) && (!obj->prev.have_clipees)))) + (_evas_render_can_render(eo_obj) || + (evas_object_was_visible(eo_obj, obj) && (!obj->prev.have_clipees)))) { if (obj->render_pre || obj->rect_del) ok = EINA_TRUE; } @@ -571,10 +624,10 @@ _evas_render_check_pending_objects(Eina_Array *pending_objects, Evas *e) else { if ((!obj->clip.clipees) && (obj->delete_me == 0) && - (!obj->cur.have_clipees || (evas_object_was_visible(obj) && (!obj->prev.have_clipees))) - && evas_object_is_opaque(obj) && evas_object_is_visible(obj)) + (!obj->cur.have_clipees || (evas_object_was_visible(eo_obj, obj) && (!obj->prev.have_clipees))) + && evas_object_is_opaque(eo_obj, obj) && evas_object_is_visible(eo_obj, obj)) { - if (obj->rect_del || obj->smart.smart) ok = EINA_TRUE; + if (obj->rect_del || obj->is_smart) ok = EINA_TRUE; } } } @@ -593,27 +646,29 @@ clean_stuff: } Eina_Bool -pending_change(void *data, void *gdata __UNUSED__) +pending_change(void *data, void *gdata EINA_UNUSED) { - Evas_Object *obj; + Evas_Object *eo_obj; - obj = data; + Evas_Object_Protected_Data *obj = data; + eo_obj = obj->object; if (obj->delete_me) return EINA_FALSE; if (obj->pre_render_done) { RD(" OBJ [%p] pending change %i -> 0, pre %i\n", obj, obj->changed, obj->pre_render_done); - obj->func->render_post(obj); + obj->func->render_post(eo_obj, obj); obj->pre_render_done = EINA_FALSE; - evas_object_change_reset(obj); + evas_object_change_reset(eo_obj); } return obj->changed ? EINA_TRUE : EINA_FALSE; } static Eina_Bool -_evas_render_can_use_overlay(Evas *e, Evas_Object *obj) +_evas_render_can_use_overlay(Evas *eo_e, Evas_Object *eo_obj) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Eina_Rectangle *r; - Evas_Object *tmp; + Evas_Object *eo_tmp; Eina_List *alphas = NULL; Eina_List *opaques = NULL; Evas_Object *video_parent = NULL; @@ -622,16 +677,20 @@ _evas_render_can_use_overlay(Evas *e, Evas_Object *obj) unsigned int i; Eina_Bool nooverlay; - video_parent = _evas_object_image_video_parent_get(obj); + video_parent = _evas_object_image_video_parent_get(eo_obj); /* Check if any one is the stack make this object mapped */ - tmp = obj; - while (tmp && !_evas_render_has_map(tmp)) - tmp = tmp->smart.parent; + eo_tmp = eo_obj; + while (eo_tmp && !_evas_render_has_map(eo_tmp)) + { + Evas_Object_Protected_Data *tmp = eo_data_get(eo_tmp, EVAS_OBJ_CLASS); + eo_tmp = tmp->smart.parent; + } - if (tmp && _evas_render_has_map(tmp)) return EINA_FALSE; /* we are mapped, we can't be an overlay */ + if (eo_tmp && _evas_render_has_map(eo_tmp)) return EINA_FALSE; /* we are mapped, we can't be an overlay */ - if (!evas_object_is_visible(obj)) return EINA_FALSE; /* no need to update the overlay if it's not visible */ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (!evas_object_is_visible(eo_obj, obj)) return EINA_FALSE; /* no need to update the overlay if it's not visible */ /* If any recoloring of the surface is needed, n overlay to */ if ((obj->cur.cache.clip.r != 255) || @@ -651,14 +710,15 @@ _evas_render_can_use_overlay(Evas *e, Evas_Object *obj) { Eina_Rectangle self; Eina_Rectangle *match; - Evas_Object *current; + Evas_Object *eo_current; Eina_List *l; int xm1, ym1, xm2, ym2; - current = eina_array_data_get(&e->active_objects, i); + Evas_Object_Protected_Data *current = eina_array_data_get(&e->active_objects, i); + eo_current = current->object; /* Did we find the video object in the stack ? */ - if (current == video_parent || current == obj) + if (eo_current == video_parent || eo_current == eo_obj) break; EINA_RECTANGLE_SET(&self, @@ -676,18 +736,18 @@ _evas_render_can_use_overlay(Evas *e, Evas_Object *obj) xc2 = current->cur.cache.clip.x + current->cur.cache.clip.w; yc2 = current->cur.cache.clip.y + current->cur.cache.clip.h; - if (evas_object_is_visible(current) && + if (evas_object_is_visible(eo_current, current) && (!current->clip.clipees) && (current->cur.visible) && (!current->delete_me) && (current->cur.cache.clip.visible) && - (!current->smart.smart)) + (!eo_isa(eo_current, EVAS_OBJ_SMART_CLASS))) { Eina_Bool included = EINA_FALSE; - if (evas_object_is_opaque(current) || + if (evas_object_is_opaque(eo_current, current) || ((current->func->has_opaque_rect) && - (current->func->has_opaque_rect(current)))) + (current->func->has_opaque_rect(eo_current, current)))) { /* The object is opaque */ @@ -804,7 +864,8 @@ _evas_render_can_use_overlay(Evas *e, Evas_Object *obj) } Eina_Bool -evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, +evas_render_mapped(Evas *eo_e, Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, + void *context, void *surface, int off_x, int off_y, int mapped, int ecx, int ecy, int ecw, int ech #ifdef REND_DBG @@ -812,17 +873,18 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, #endif ) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); void *ctx; - Evas_Object *obj2; + Evas_Object_Protected_Data *obj2; Eina_Bool clean_them = EINA_FALSE; - evas_object_clip_recalc(obj); + evas_object_clip_recalc(eo_obj, obj); RDI(level); RD(" { evas_render_mapped(%p, %p, %p, %p, %i, %i, %i, %i)\n", e, obj, context, surface, off_x, off_y, mapped, level); if (mapped) { - if ((!evas_object_is_visible(obj)) || (obj->clip.clipees) || + if ((!evas_object_is_visible(eo_obj, obj)) || (obj->clip.clipees) || (obj->cur.have_clipees)) { RDI(level); @@ -830,8 +892,8 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, return clean_them; } } - else if (!(((evas_object_is_active(obj) && (!obj->clip.clipees) && - (_evas_render_can_render(obj)))) + else if (!(((evas_object_is_active(eo_obj, obj) && (!obj->clip.clipees) && + (_evas_render_can_render(eo_obj)))) )) { RDI(level); @@ -842,10 +904,10 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, // set render_pre - for child objs that may not have gotten it. obj->pre_render_done = EINA_TRUE; RD(" Hasmap: %p (%d) %p %d -> %d\n",obj->func->can_map, - obj->func->can_map ? obj->func->can_map(obj): -1, + obj->func->can_map ? obj->func->can_map(eo_obj): -1, obj->cur.map, obj->cur.usemap, - _evas_render_has_map(obj)); - if (_evas_render_has_map(obj)) + _evas_render_has_map(eo_obj)); + if (_evas_render_has_map(eo_obj)) { int sw, sh; Eina_Bool changed = EINA_FALSE, rendered = EINA_FALSE; @@ -862,7 +924,7 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, RD(" }\n"); return clean_them; } - evas_object_map_update(obj, off_x, off_y, sw, sh, sw, sh); + evas_object_map_update(eo_obj, off_x, off_y, sw, sh, sw, sh); if (obj->map.surface) { @@ -890,14 +952,16 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, RD(" fisrt surf: %ix%i\n", sw, sh); changed = EINA_TRUE; } - if (obj->smart.smart) + if (obj->is_smart) { - Evas_Object *o2; + Evas_Object *eo_o2; + Evas_Object_Protected_Data *o2; - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), o2) + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), o2) { - if (!evas_object_is_visible(o2) && - !evas_object_was_visible(o2)) + eo_o2 = o2->object; + if (!evas_object_is_visible(eo_o2, o2) && + !evas_object_was_visible(eo_o2, o2)) { continue; } @@ -948,12 +1012,12 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, ctx = e->engine.func->context_new(e->engine.data.output); off_x2 = -obj->cur.geometry.x; off_y2 = -obj->cur.geometry.y; - if (obj->smart.smart) + if (obj->is_smart) { EINA_INLIST_FOREACH - (evas_object_smart_members_get_direct(obj), obj2) + (evas_object_smart_members_get_direct(eo_obj), obj2) { - clean_them |= evas_render_mapped(e, obj2, ctx, + clean_them |= evas_render_mapped(eo_e, obj2->object, obj2, ctx, obj->map.surface, off_x2, off_y2, 1, ecx, ecy, ecw, ech @@ -977,7 +1041,7 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, e->engine.func->context_clip_set(e->engine.data.output, ctx, x, y, w, h); - obj->func->render(obj, e->engine.data.output, ctx, + obj->func->render(eo_obj, obj, e->engine.data.output, ctx, obj->map.surface, off_x2, off_y2); } e->engine.func->context_free(e->engine.data.output, ctx); @@ -1000,33 +1064,33 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, { if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); int x, y, w, h; - evas_object_clip_recalc(obj); + evas_object_clip_recalc(eo_obj, obj); x = obj->cur.cache.clip.x; y = obj->cur.cache.clip.y; w = obj->cur.cache.clip.w; h = obj->cur.cache.clip.h; - if (obj->smart.smart) + if (obj->is_smart) { Evas_Object *tobj; obj->cur.cache.clip.dirty = EINA_TRUE; tobj = obj->cur.map_parent; - obj->cur.map_parent = obj->cur.clipper->cur.map_parent; + obj->cur.map_parent = cur_clipper->cur.map_parent; obj->cur.map_parent = tobj; } RECTS_CLIP_TO_RECT(x, y, w, h, - obj->cur.clipper->cur.cache.clip.x, - obj->cur.clipper->cur.cache.clip.y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x, + cur_clipper->cur.cache.clip.y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); e->engine.func->context_clip_set(e->engine.data.output, context, x + off_x, y + off_y, w, h); - } } // if (surface == e->engine.data.output) @@ -1052,7 +1116,7 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, { if (0 && obj->cur.cached_surface) fprintf(stderr, "We should cache '%s' [%i, %i, %i, %i]\n", - evas_object_type_get(obj), + evas_object_type_get(eo_obj), obj->cur.bounding_box.x, obj->cur.bounding_box.x, obj->cur.bounding_box.w, obj->cur.bounding_box.h); if (mapped) @@ -1060,12 +1124,12 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, RDI(level); RD(" draw child of mapped obj\n"); ctx = e->engine.func->context_new(e->engine.data.output); - if (obj->smart.smart) + if (obj->is_smart) { EINA_INLIST_FOREACH - (evas_object_smart_members_get_direct(obj), obj2) + (evas_object_smart_members_get_direct(eo_obj), obj2) { - clean_them |= evas_render_mapped(e, obj2, ctx, + clean_them |= evas_render_mapped(eo_e, obj2->object, obj2, ctx, surface, off_x, off_y, 1, ecx, ecy, ecw, ech @@ -1091,16 +1155,17 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, obj->cur.geometry.w, obj->cur.geometry.h); + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); RD(" clipper: %i %i %ix%i\n", - obj->cur.clipper->cur.cache.clip.x + off_x, - obj->cur.clipper->cur.cache.clip.y + off_y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x + off_x, + cur_clipper->cur.cache.clip.y + off_y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); int x, y, w, h; - if (_evas_render_has_map(obj)) - evas_object_clip_recalc(obj); + if (_evas_render_has_map(eo_obj)) + evas_object_clip_recalc(eo_obj, obj); x = obj->cur.cache.clip.x + off_x; y = obj->cur.cache.clip.y + off_y; @@ -1108,15 +1173,15 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, h = obj->cur.cache.clip.h; RECTS_CLIP_TO_RECT(x, y, w, h, - obj->cur.clipper->cur.cache.clip.x + off_x, - obj->cur.clipper->cur.cache.clip.y + off_y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x + off_x, + cur_clipper->cur.cache.clip.y + off_y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); e->engine.func->context_clip_set(e->engine.data.output, ctx, x, y, w, h); } - obj->func->render(obj, e->engine.data.output, ctx, + obj->func->render(eo_obj, obj, e->engine.data.output, ctx, surface, off_x, off_y); } e->engine.func->context_free(e->engine.data.output, ctx); @@ -1125,19 +1190,20 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, { if (obj->cur.clipper) { + Evas_Object_Protected_Data *cur_clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); int x, y, w, h; - if (_evas_render_has_map(obj)) - evas_object_clip_recalc(obj); + if (_evas_render_has_map(eo_obj)) + evas_object_clip_recalc(eo_obj, obj); x = obj->cur.cache.clip.x; y = obj->cur.cache.clip.y; w = obj->cur.cache.clip.w; h = obj->cur.cache.clip.h; RECTS_CLIP_TO_RECT(x, y, w, h, - obj->cur.clipper->cur.cache.clip.x, - obj->cur.clipper->cur.cache.clip.y, - obj->cur.clipper->cur.cache.clip.w, - obj->cur.clipper->cur.cache.clip.h); + cur_clipper->cur.cache.clip.x, + cur_clipper->cur.cache.clip.y, + cur_clipper->cur.cache.clip.w, + cur_clipper->cur.cache.clip.h); e->engine.func->context_clip_set(e->engine.data.output, context, x + off_x, y + off_y, w, h); @@ -1148,7 +1214,7 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, RDI(level); RD(" draw normal obj\n"); - obj->func->render(obj, e->engine.data.output, context, surface, + obj->func->render(eo_obj, obj, e->engine.data.output, context, surface, off_x, off_y); } if (obj->changed_map) clean_them = EINA_TRUE; @@ -1160,9 +1226,11 @@ evas_render_mapped(Evas *e, Evas_Object *obj, void *context, void *surface, } static void -_evas_render_cutout_add(Evas *e, Evas_Object *obj, int off_x, int off_y) +_evas_render_cutout_add(Evas *eo_e, Evas_Object *eo_obj, int off_x, int off_y) { - if (evas_object_is_opaque(obj)) + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + if (evas_object_is_opaque(eo_obj, obj)) { Evas_Coord cox, coy, cow, coh; @@ -1172,12 +1240,14 @@ _evas_render_cutout_add(Evas *e, Evas_Object *obj, int off_x, int off_y) coh = obj->cur.cache.clip.h; if ((obj->cur.map) && (obj->cur.usemap)) { - Evas_Object *oo; + Evas_Object *eo_oo; - oo = obj; + eo_oo = eo_obj; + Evas_Object_Protected_Data *oo = eo_data_get(eo_oo, EVAS_OBJ_CLASS); while (oo->cur.clipper) { - if ((oo->cur.clipper->cur.map_parent + Evas_Object_Protected_Data *oo_cur_clipper = eo_data_get(oo->cur.clipper, EVAS_OBJ_CLASS); + if ((oo_cur_clipper->cur.map_parent != oo->cur.map_parent) && (!((oo->cur.map) && (oo->cur.usemap)))) break; @@ -1186,7 +1256,8 @@ _evas_render_cutout_add(Evas *e, Evas_Object *obj, int off_x, int off_y) oo->cur.geometry.y, oo->cur.geometry.w, oo->cur.geometry.h); - oo = oo->cur.clipper; + eo_oo = oo->cur.clipper; + oo = eo_data_get(eo_oo, EVAS_OBJ_CLASS); } } e->engine.func->context_cutout_add @@ -1199,7 +1270,7 @@ _evas_render_cutout_add(Evas *e, Evas_Object *obj, int off_x, int off_y) { Evas_Coord obx, oby, obw, obh; - obj->func->get_opaque_rect(obj, &obx, &oby, &obw, &obh); + obj->func->get_opaque_rect(eo_obj, obj, &obx, &oby, &obw, &obh); if ((obw > 0) && (obh > 0)) { obx += off_x; @@ -1218,11 +1289,12 @@ _evas_render_cutout_add(Evas *e, Evas_Object *obj, int off_x, int off_y) } static Eina_List * -evas_render_updates_internal(Evas *e, +evas_render_updates_internal(Evas *eo_e, unsigned char make_updates, unsigned char do_draw) { - Evas_Object *obj; + Evas_Object *eo_obj; + Evas_Object_Protected_Data *obj; Eina_List *updates = NULL; Eina_List *ll; void *surface; @@ -1235,28 +1307,29 @@ evas_render_updates_internal(Evas *e, int redraw_all = 0; Eina_Bool haveup = 0; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); if (!e->changed) return NULL; #ifdef EVAS_CSERVE2 if (evas_cserve2_use_get()) evas_cserve2_dispatch(); #endif - evas_call_smarts_calculate(e); + evas_call_smarts_calculate(eo_e); RD("[--- RENDER EVAS (size: %ix%i)\n", e->viewport.w, e->viewport.h); - evas_event_callback_call(e, EVAS_CALLBACK_RENDER_PRE, NULL); + evas_event_callback_call(eo_e, EVAS_CALLBACK_RENDER_PRE, NULL); /* Check if the modified object mean recalculating every thing */ if (!e->invalidate) - _evas_render_check_pending_objects(&e->pending_objects, e); + _evas_render_check_pending_objects(&e->pending_objects, eo_e, e); /* phase 1. add extra updates for changed objects */ if (e->invalidate || e->render_objects.count <= 0) - clean_them = _evas_render_phase1_process(e, + clean_them = _evas_render_phase1_process(eo_e, &e->active_objects, &e->restack_objects, &e->delete_objects, @@ -1265,26 +1338,27 @@ evas_render_updates_internal(Evas *e, /* phase 1.5. check if the video should be inlined or stay in their overlay */ alpha = e->engine.func->canvas_alpha_get(e->engine.data.output, - e->engine.data.context); + e->engine.data.context); - EINA_LIST_FOREACH(e->video_objects, ll, obj) + EINA_LIST_FOREACH(e->video_objects, ll, eo_obj) { /* we need the surface to be transparent to display the underlying overlay */ - if (alpha && _evas_render_can_use_overlay(e, obj)) - _evas_object_image_video_overlay_show(obj); + if (alpha && _evas_render_can_use_overlay(eo_e, eo_obj)) + _evas_object_image_video_overlay_show(eo_obj); else - _evas_object_image_video_overlay_hide(obj); + _evas_object_image_video_overlay_hide(eo_obj); } /* phase 1.8. pre render for proxy */ - _evas_render_phase1_direct(e, &e->active_objects, &e->restack_objects, + _evas_render_phase1_direct(eo_e, &e->active_objects, &e->restack_objects, &e->delete_objects, &e->render_objects); /* phase 2. force updates for restacks */ for (i = 0; i < e->restack_objects.count; ++i) { obj = eina_array_data_get(&e->restack_objects, i); - obj->func->render_pre(obj); - _evas_render_prev_cur_clip_cache_add(e, obj); + eo_obj = obj->object; + obj->func->render_pre(eo_obj, obj); + _evas_render_prev_cur_clip_cache_add(eo_e, eo_obj); } eina_array_clean(&e->restack_objects); @@ -1343,7 +1417,7 @@ evas_render_updates_internal(Evas *e, /* see if the master clip has been added yet, if not, then create */ if (!e->framespace.clip) { - e->framespace.clip = evas_object_rectangle_add(e); + e->framespace.clip = evas_object_rectangle_add(eo_e); evas_object_color_set(e->framespace.clip, 255, 255, 255, 255); evas_object_move(e->framespace.clip, e->framespace.x, e->framespace.y); @@ -1367,11 +1441,12 @@ evas_render_updates_internal(Evas *e, } } + Evas_Object_Protected_Data *framespace_clip = eo_data_get(e->framespace.clip, EVAS_OBJ_CLASS); EINA_RECTANGLE_SET(&clip_rect, - e->framespace.clip->cur.geometry.x, - e->framespace.clip->cur.geometry.y, - e->framespace.clip->cur.geometry.w, - e->framespace.clip->cur.geometry.h) + framespace_clip->cur.geometry.x, + framespace_clip->cur.geometry.y, + framespace_clip->cur.geometry.w, + framespace_clip->cur.geometry.h) /* With the master clip all setup, we need to loop the objects on this * canvas and determine if the object is in the viewport space. If it @@ -1396,14 +1471,14 @@ evas_render_updates_internal(Evas *e, if (!eina_rectangles_intersect(&clip_rect, &obj_rect)) continue; - if (!(pclip = evas_object_clip_get(obj))) + if (!(pclip = evas_object_clip_get(eo_obj))) { /* skip clipping if the object is itself the * framespace clip */ - if (obj == e->framespace.clip) continue; + if (eo_obj == e->framespace.clip) continue; /* clip this object so it does not draw on the window frame */ - evas_object_clip_set(obj, e->framespace.clip); + evas_object_clip_set(eo_obj, e->framespace.clip); } } } @@ -1424,15 +1499,16 @@ evas_render_updates_internal(Evas *e, for (i = 0; i < e->active_objects.count; ++i) { obj = eina_array_data_get(&e->active_objects, i); - if (UNLIKELY((evas_object_is_opaque(obj) || + eo_obj = obj->object; + if (UNLIKELY((evas_object_is_opaque(eo_obj, obj) || ((obj->func->has_opaque_rect) && - (obj->func->has_opaque_rect(obj)))) && - evas_object_is_visible(obj) && + (obj->func->has_opaque_rect(eo_obj, obj)))) && + evas_object_is_visible(eo_obj, obj) && (!obj->clip.clipees) && (obj->cur.visible) && (!obj->delete_me) && (obj->cur.cache.clip.visible) && - (!obj->smart.smart))) + (!obj->is_smart))) /* obscuring_objects = eina_list_append(obscuring_objects, obj); */ eina_array_push(&e->obscuring_objects, obj); } @@ -1474,15 +1550,16 @@ evas_render_updates_internal(Evas *e, } for (i = 0; i < e->obscuring_objects.count; ++i) { - obj = (Evas_Object *)eina_array_data_get + obj = (Evas_Object_Protected_Data *)eina_array_data_get (&e->obscuring_objects, i); - if (evas_object_is_in_output_rect(obj, ux, uy, uw, uh)) + eo_obj = obj->object; + if (evas_object_is_in_output_rect(eo_obj, obj, ux, uy, uw, uh)) { eina_array_push(&e->temporary_objects, obj); /* reset the background of the area if needed (using cutout and engine alpha flag to help) */ if (alpha) - _evas_render_cutout_add(e, obj, off_x, off_y); + _evas_render_cutout_add(eo_e, eo_obj, off_x, off_y); } } if (alpha) @@ -1509,16 +1586,17 @@ evas_render_updates_internal(Evas *e, for (i = 0; i < e->active_objects.count; ++i) { obj = eina_array_data_get(&e->active_objects, i); + eo_obj = obj->object; /* if it's in our outpout rect and it doesn't clip anything */ RD(" OBJ: [%p] '%s' %i %i %ix%i\n", obj, obj->type, obj->cur.geometry.x, obj->cur.geometry.y, obj->cur.geometry.w, obj->cur.geometry.h); - if ((evas_object_is_in_output_rect(obj, ux, uy, uw, uh) || - (obj->smart.smart)) && + if ((evas_object_is_in_output_rect(eo_obj, obj, ux, uy, uw, uh) || + (obj->is_smart)) && (!obj->clip.clipees) && (obj->cur.visible) && (!obj->delete_me) && (obj->cur.cache.clip.visible) && -// (!obj->smart.smart) && +// (!obj->is_smart) && ((obj->cur.color.a > 0 || obj->cur.render_op != EVAS_RENDER_BLEND))) { int x, y, w, h; @@ -1528,9 +1606,9 @@ evas_render_updates_internal(Evas *e, (eina_array_data_get(&e->temporary_objects, offset) == obj)) offset++; x = cx; y = cy; w = cw; h = ch; - if (((w > 0) && (h > 0)) || (obj->smart.smart)) + if (((w > 0) && (h > 0)) || (obj->is_smart)) { - if (!obj->smart.smart) + if (!obj->is_smart) { RECTS_CLIP_TO_RECT(x, y, w, h, obj->cur.cache.clip.x + off_x, @@ -1539,13 +1617,16 @@ evas_render_updates_internal(Evas *e, obj->cur.cache.clip.h); } if (obj->cur.mask) - e->engine.func->context_mask_set(e->engine.data.output, + { + Evas_Object_Protected_Data *cur_mask = eo_data_get(obj->cur.mask, EVAS_OBJ_CLASS); + e->engine.func->context_mask_set(e->engine.data.output, e->engine.data.context, - obj->cur.mask->func->engine_data_get(obj->cur.mask), - obj->cur.mask->cur.geometry.x + off_x, - obj->cur.mask->cur.geometry.y + off_y, - obj->cur.mask->cur.geometry.w, - obj->cur.mask->cur.geometry.h); + cur_mask->func->engine_data_get(obj->cur.mask), + cur_mask->cur.geometry.x + off_x, + cur_mask->cur.geometry.y + off_y, + cur_mask->cur.geometry.w, + cur_mask->cur.geometry.h); + } else e->engine.func->context_mask_unset(e->engine.data.output, e->engine.data.context); @@ -1555,14 +1636,14 @@ evas_render_updates_internal(Evas *e, #if 1 /* FIXME: this can slow things down... figure out optimum... coverage */ for (j = offset; j < e->temporary_objects.count; ++j) { - Evas_Object *obj2; + Evas_Object_Protected_Data *obj2; - obj2 = (Evas_Object *)eina_array_data_get + obj2 = (Evas_Object_Protected_Data *)eina_array_data_get (&e->temporary_objects, j); - _evas_render_cutout_add(e, obj2, off_x, off_y); + _evas_render_cutout_add(eo_e, obj2->object, off_x, off_y); } #endif - clean_them |= evas_render_mapped(e, obj, e->engine.data.context, + clean_them |= evas_render_mapped(eo_e, eo_obj, obj, e->engine.data.context, surface, off_x, off_y, 0, cx, cy, cw, ch #ifdef REND_DBG @@ -1585,9 +1666,9 @@ evas_render_updates_internal(Evas *e, /* flush redraws */ if (haveup) { - evas_event_callback_call(e, EVAS_CALLBACK_RENDER_FLUSH_PRE, NULL); + evas_event_callback_call(eo_e, EVAS_CALLBACK_RENDER_FLUSH_PRE, NULL); e->engine.func->output_flush(e->engine.data.output); - evas_event_callback_call(e, EVAS_CALLBACK_RENDER_FLUSH_POST, NULL); + evas_event_callback_call(eo_e, EVAS_CALLBACK_RENDER_FLUSH_POST, NULL); } } /* clear redraws */ @@ -1596,21 +1677,22 @@ evas_render_updates_internal(Evas *e, for (i = 0; i < e->active_objects.count; ++i) { obj = eina_array_data_get(&e->active_objects, i); + eo_obj = obj->object; obj->pre_render_done = EINA_FALSE; RD(" OBJ [%p] post... %i %i\n", obj, obj->changed, do_draw); if ((obj->changed) && (do_draw)) { RD(" OBJ [%p] post... func1\n", obj); - obj->func->render_post(obj); + obj->func->render_post(eo_obj, obj); obj->restack = EINA_FALSE; - evas_object_change_reset(obj); + evas_object_change_reset(eo_obj); } else if (clean_them) { RD(" OBJ [%p] post... func2\n", obj); - obj->func->render_post(obj); + obj->func->render_post(eo_obj, obj); obj->restack = EINA_FALSE; - evas_object_change_reset(obj); + evas_object_change_reset(eo_obj); } /* moved to other pre-process phase 1 if (obj->delete_me == 2) @@ -1630,12 +1712,13 @@ evas_render_updates_internal(Evas *e, for (i = 0; i < e->render_objects.count; ++i) { obj = eina_array_data_get(&e->render_objects, i); + eo_obj = obj->object; obj->pre_render_done = EINA_FALSE; if ((obj->changed) && (do_draw)) { - obj->func->render_post(obj); + obj->func->render_post(eo_obj, obj); obj->restack = EINA_FALSE; - evas_object_change_reset(obj); + evas_object_change_reset(eo_obj); } } @@ -1643,7 +1726,8 @@ evas_render_updates_internal(Evas *e, for (i = 0; i < e->delete_objects.count; ++i) { obj = eina_array_data_get(&e->delete_objects, i); - evas_object_free(obj, 1); + eo_obj = obj->object; + evas_object_free(eo_obj, 1); } eina_array_clean(&e->delete_objects); @@ -1677,7 +1761,7 @@ evas_render_updates_internal(Evas *e, evas_module_clean(); - evas_event_callback_call(e, EVAS_CALLBACK_RENDER_POST, NULL); + evas_event_callback_call(eo_e, EVAS_CALLBACK_RENDER_POST, NULL); RD("---]\n"); @@ -1694,46 +1778,80 @@ evas_render_updates_free(Eina_List *updates) } EAPI Eina_List * -evas_render_updates(Evas *e) +evas_render_updates(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Eina_List *ret = NULL; + eo_do(eo_e, evas_canvas_render_updates(&ret)); + return ret; +} - if (!e->changed) return NULL; - return evas_render_updates_internal(e, 1, 1); +void +_canvas_render_updates(Eo *eo_e, void *_pd, va_list *list) +{ + Eina_List **ret = va_arg(*list, Eina_List **); + + Evas_Public_Data *e = _pd; + + if (!e->changed) + { + *ret = NULL; + return; + } + *ret = evas_render_updates_internal(eo_e, 1, 1); } EAPI void -evas_render(Evas *e) +evas_render(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_render()); +} + +void +_canvas_render(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; if (!e->changed) return; - evas_render_updates_internal(e, 0, 1); + evas_render_updates_internal(eo_e, 0, 1); } EAPI void -evas_norender(Evas *e) +evas_norender(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_norender()); +} +void +_canvas_norender(Eo *eo_e, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ // if (!e->changed) return; - evas_render_updates_internal(e, 0, 0); + evas_render_updates_internal(eo_e, 0, 0); } EAPI void -evas_render_idle_flush(Evas *e) +evas_render_idle_flush(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_render_idle_flush()); +} - evas_fonts_zero_presure(e); +void +_canvas_render_idle_flush(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) +{ + Evas_Public_Data *e = _pd; + + evas_fonts_zero_presure(eo_e); if ((e->engine.func) && (e->engine.func->output_idle_flush) && (e->engine.data.output)) @@ -1751,14 +1869,20 @@ evas_render_idle_flush(Evas *e) } EAPI void -evas_sync(Evas *e) +evas_sync(Evas *eo_e) { - (void) e; + eo_do(eo_e, evas_canvas_sync()); } -static void -_evas_render_dump_map_surfaces(Evas_Object *obj) +void +_canvas_sync(Eo *eo_e EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) { +} + +void +_evas_render_dump_map_surfaces(Evas_Object *eo_obj) +{ + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if ((obj->cur.map) && obj->map.surface) { obj->layer->evas->engine.func->image_map_surface_free @@ -1766,33 +1890,39 @@ _evas_render_dump_map_surfaces(Evas_Object *obj) obj->map.surface = NULL; } - if (obj->smart.smart) + if (obj->is_smart) { - Evas_Object *obj2; + Evas_Object_Protected_Data *obj2; - EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(obj), obj2) - _evas_render_dump_map_surfaces(obj2); + EINA_INLIST_FOREACH(evas_object_smart_members_get_direct(eo_obj), obj2) + _evas_render_dump_map_surfaces(obj2->object); } } EAPI void -evas_render_dump(Evas *e) +evas_render_dump(Evas *eo_e) +{ + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return; + MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_render_dump()); +} + +void +_canvas_render_dump(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED) { Evas_Layer *lay; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return; - MAGIC_CHECK_END(); - + Evas_Public_Data *e = _pd; EINA_INLIST_FOREACH(e->layers, lay) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; EINA_INLIST_FOREACH(lay->objects, obj) { if ((obj->type) && (!strcmp(obj->type, "image"))) - evas_object_inform_call_image_unloaded(obj); - _evas_render_dump_map_surfaces(obj); + evas_object_inform_call_image_unloaded(obj->object); + _evas_render_dump_map_surfaces(obj->object); } } if ((e->engine.func) && (e->engine.func->output_dump) && @@ -1801,11 +1931,12 @@ evas_render_dump(Evas *e) } void -evas_render_invalidate(Evas *e) +evas_render_invalidate(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return; MAGIC_CHECK_END(); + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); eina_array_clean(&e->active_objects); eina_array_clean(&e->render_objects); @@ -1817,15 +1948,15 @@ evas_render_invalidate(Evas *e) } void -evas_render_object_recalc(Evas_Object *obj) +evas_render_object_recalc(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); if ((!obj->changed) && (obj->delete_me < 2)) { - Evas *e; + Evas_Public_Data *e; e = obj->layer->evas; if ((!e) || (e->cleanup)) return; diff --git a/legacy/evas/src/lib/canvas/evas_stack.c b/legacy/evas/src/lib/canvas/evas_stack.c index a8dec0decd..47f8cc18ef 100644 --- a/legacy/evas/src/lib/canvas/evas_stack.c +++ b/legacy/evas/src/lib/canvas/evas_stack.c @@ -1,80 +1,88 @@ #include "evas_common.h" #include "evas_private.h" -static Evas_Object * -evas_object_above_get_internal(const Evas_Object *obj) +static Evas_Object_Protected_Data * +evas_object_above_get_internal(const Evas_Object_Protected_Data *obj) { if ((EINA_INLIST_GET(obj))->next) - return (Evas_Object *)((EINA_INLIST_GET(obj))->next); + return (Evas_Object_Protected_Data *)((EINA_INLIST_GET(obj))->next); else { - if ((EINA_INLIST_GET(((Evas_Object*)(obj))->layer))->next) + if ((EINA_INLIST_GET(obj->layer))->next) { Evas_Layer *l; - l = (Evas_Layer *)((EINA_INLIST_GET((((Evas_Object *)obj)->layer)))->next); + l = (Evas_Layer *)((EINA_INLIST_GET(obj->layer))->next); return l->objects; } } return NULL; } -static Evas_Object * -evas_object_below_get_internal(const Evas_Object *obj) +static Evas_Object_Protected_Data * +evas_object_below_get_internal(const Evas_Object_Protected_Data *obj) { if ((EINA_INLIST_GET(obj))->prev) - return (Evas_Object *)((EINA_INLIST_GET(obj))->prev); + return (Evas_Object_Protected_Data *)((EINA_INLIST_GET(obj))->prev); else { - if ((EINA_INLIST_GET((((Evas_Object *)obj)->layer)))->prev) + if ((EINA_INLIST_GET(obj->layer))->prev) { Evas_Layer *l; - l = (Evas_Layer *)((EINA_INLIST_GET((((Evas_Object *)obj)->layer)))->prev); - return (Evas_Object *)((EINA_INLIST_GET((l->objects)))->last); + l = (Evas_Layer *)((EINA_INLIST_GET(obj->layer))->prev); + return (Evas_Object_Protected_Data *)((EINA_INLIST_GET((l->objects)))->last); } } return NULL; } EAPI void -evas_object_raise(Evas_Object *obj) +evas_object_raise(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - if (evas_object_intercept_call_raise(obj)) return; + eo_do(eo_obj, evas_obj_raise()); +} + +void +_raise(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + if (evas_object_intercept_call_raise(eo_obj)) return; + + Evas_Object_Protected_Data *obj = _pd; if (!((EINA_INLIST_GET(obj))->next)) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } if (obj->smart.parent) - evas_object_smart_member_raise(obj); + evas_object_smart_member_raise(eo_obj); else { if (obj->in_layer) - obj->layer->objects = (Evas_Object *)eina_inlist_demote(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj)); + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_demote(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj)); } if (obj->clip.clipees) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } - if (obj->layer) evas_render_invalidate(obj->layer->evas); + if (obj->layer) evas_render_invalidate(obj->layer->evas->evas); obj->restack = EINA_TRUE; - evas_object_change(obj); - evas_object_inform_call_restack(obj); - if (obj->layer->evas->events_frozen > 0) return; - if ((!evas_event_passes_through(obj)) && (!evas_event_freezes_through(obj))) + evas_object_change(eo_obj, obj); + evas_object_inform_call_restack(eo_obj); + if (obj->layer->evas->is_frozen) return; + if ((!evas_event_passes_through(eo_obj, obj)) && (!evas_event_freezes_through(eo_obj, obj))) { - if (!obj->smart.smart) + if (!obj->is_smart) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -84,44 +92,52 @@ evas_object_raise(Evas_Object *obj) } EAPI void -evas_object_lower(Evas_Object *obj) +evas_object_lower(Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - if (evas_object_intercept_call_lower(obj)) return; + eo_do(eo_obj, evas_obj_lower()); +} + +void +_lower(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +{ + if (evas_object_intercept_call_lower(eo_obj)) return; + + Evas_Object_Protected_Data *obj = _pd; if (!((EINA_INLIST_GET(obj))->prev)) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } if (obj->smart.parent) - evas_object_smart_member_lower(obj); + evas_object_smart_member_lower(eo_obj); else { if (obj->in_layer) - obj->layer->objects = (Evas_Object *)eina_inlist_promote(EINA_INLIST_GET(obj->layer->objects), - EINA_INLIST_GET(obj)); + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_promote(EINA_INLIST_GET(obj->layer->objects), + EINA_INLIST_GET(obj)); } if (obj->clip.clipees) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } - if (obj->layer) evas_render_invalidate(obj->layer->evas); + if (obj->layer) evas_render_invalidate(obj->layer->evas->evas); obj->restack = EINA_TRUE; - evas_object_change(obj); - evas_object_inform_call_restack(obj); - if (obj->layer->evas->events_frozen > 0) return; - if ((!evas_event_passes_through(obj)) && (!evas_event_freezes_through(obj))) + evas_object_change(eo_obj, obj); + evas_object_inform_call_restack(eo_obj); + if (obj->layer->evas->is_frozen) return; + if ((!evas_event_passes_through(eo_obj, obj)) && (!evas_event_freezes_through(eo_obj, obj))) { - if (!obj->smart.smart) + if (!obj->is_smart) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -131,75 +147,82 @@ evas_object_lower(Evas_Object *obj) } EAPI void -evas_object_stack_above(Evas_Object *obj, Evas_Object *above) +evas_object_stack_above(Evas_Object *eo_obj, Evas_Object *above) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - MAGIC_CHECK(above, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - if (obj == above) return; - if (evas_object_intercept_call_stack_above(obj, above)) return; - if (!above) + eo_do(eo_obj, evas_obj_stack_above(above)); +} + +void +_stack_above(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object *eo_above = va_arg(*list, Evas_Object *); + if (!eo_above) return; + if (eo_obj == eo_above) return; + if (evas_object_intercept_call_stack_above(eo_obj, eo_above)) return; + if (!eo_above) { - evas_object_raise(obj); + evas_object_raise(eo_obj); return; } + Evas_Object_Protected_Data *obj = _pd; + Evas_Object_Protected_Data *above = eo_data_get(eo_above, EVAS_OBJ_CLASS); if ((EINA_INLIST_GET(obj))->prev == EINA_INLIST_GET(above)) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } if (obj->smart.parent) { if (obj->smart.parent != above->smart.parent) { - ERR("BITCH! evas_object_stack_above(), %p not inside same smart as %p!", obj, above); + ERR("BITCH! evas_object_stack_above(), %p not inside same smart as %p!", eo_obj, eo_above); return; } - evas_object_smart_member_stack_above(obj, above); + evas_object_smart_member_stack_above(eo_obj, eo_above); } else { if (above->smart.parent) { - ERR("BITCH! evas_object_stack_above(), %p stack above %p, but above has smart parent, obj does not", obj, above); + ERR("BITCH! evas_object_stack_above(), %p stack above %p, but above has smart parent, obj does not", eo_obj, eo_above); return; } if (obj->layer != above->layer) { - ERR("BITCH! evas_object_stack_above(), %p stack above %p, not matching layers", obj, above); + ERR("BITCH! evas_object_stack_above(), %p stack above %p, not matching layers", eo_obj, eo_above); return; } if (obj->in_layer) { - obj->layer->objects = (Evas_Object *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects), - EINA_INLIST_GET(obj)); - obj->layer->objects = (Evas_Object *)eina_inlist_append_relative(EINA_INLIST_GET(obj->layer->objects), - EINA_INLIST_GET(obj), - EINA_INLIST_GET(above)); + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects), + EINA_INLIST_GET(obj)); + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_append_relative(EINA_INLIST_GET(obj->layer->objects), + EINA_INLIST_GET(obj), + EINA_INLIST_GET(above)); } } if (obj->clip.clipees) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } - if (obj->layer) evas_render_invalidate(obj->layer->evas); + if (obj->layer) evas_render_invalidate(obj->layer->evas->evas); obj->restack = EINA_TRUE; - evas_object_change(obj); - evas_object_inform_call_restack(obj); - if (obj->layer->evas->events_frozen > 0) return; - if ((!evas_event_passes_through(obj)) && (!evas_event_freezes_through(obj))) + evas_object_change(eo_obj, obj); + evas_object_inform_call_restack(eo_obj); + if (obj->layer->evas->is_frozen) return; + if ((!evas_event_passes_through(eo_obj, obj)) && (!evas_event_freezes_through(eo_obj, obj))) { - if (!obj->smart.smart) + if (!obj->is_smart) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -209,75 +232,82 @@ evas_object_stack_above(Evas_Object *obj, Evas_Object *above) } EAPI void -evas_object_stack_below(Evas_Object *obj, Evas_Object *below) +evas_object_stack_below(Evas_Object *eo_obj, Evas_Object *eo_below) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - MAGIC_CHECK(below, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - if (obj == below) return; - if (evas_object_intercept_call_stack_below(obj, below)) return; - if (!below) + eo_do(eo_obj, evas_obj_stack_below(eo_below)); +} + +void +_stack_below(Eo *eo_obj, void *_pd, va_list *list) +{ + Evas_Object *eo_below = va_arg(*list, Evas_Object *); + if (!eo_below) return; + if (eo_obj == eo_below) return; + if (evas_object_intercept_call_stack_below(eo_obj, eo_below)) return; + if (!eo_below) { - evas_object_lower(obj); + evas_object_lower(eo_obj); return; } + Evas_Object_Protected_Data *obj = _pd; + Evas_Object_Protected_Data *below = eo_data_get(eo_below, EVAS_OBJ_CLASS); if ((EINA_INLIST_GET(obj))->next == EINA_INLIST_GET(below)) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } if (obj->smart.parent) { if (obj->smart.parent != below->smart.parent) { - ERR("BITCH! evas_object_stack_below(), %p not inside same smart as %p!", obj, below); + ERR("BITCH! evas_object_stack_below(), %p not inside same smart as %p!", eo_obj, eo_below); return; } - evas_object_smart_member_stack_below(obj, below); + evas_object_smart_member_stack_below(eo_obj, eo_below); } else { if (below->smart.parent) { - ERR("BITCH! evas_object_stack_below(), %p stack below %p, but below has smart parent, obj does not", obj, below); + ERR("BITCH! evas_object_stack_below(), %p stack below %p, but below has smart parent, obj does not", eo_obj, eo_below); return; } if (obj->layer != below->layer) { - ERR("BITCH! evas_object_stack_below(), %p stack below %p, not matching layers", obj, below); + ERR("BITCH! evas_object_stack_below(), %p stack below %p, not matching layers", eo_obj, eo_below); return; } if (obj->in_layer) { - obj->layer->objects = (Evas_Object *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects), + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj)); - obj->layer->objects = (Evas_Object *)eina_inlist_prepend_relative(EINA_INLIST_GET(obj->layer->objects), + obj->layer->objects = (Evas_Object_Protected_Data *)eina_inlist_prepend_relative(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj), EINA_INLIST_GET(below)); } } if (obj->clip.clipees) { - evas_object_inform_call_restack(obj); + evas_object_inform_call_restack(eo_obj); return; } - if (obj->layer) evas_render_invalidate(obj->layer->evas); + if (obj->layer) evas_render_invalidate(obj->layer->evas->evas); obj->restack = EINA_TRUE; - evas_object_change(obj); - evas_object_inform_call_restack(obj); - if (obj->layer->evas->events_frozen > 0) return; - if ((!evas_event_passes_through(obj)) && (!evas_event_freezes_through(obj))) + evas_object_change(eo_obj, obj); + evas_object_inform_call_restack(eo_obj); + if (obj->layer->evas->is_frozen) return; + if ((!evas_event_passes_through(eo_obj, obj)) && (!evas_event_freezes_through(eo_obj, obj))) { - if (!obj->smart.smart) + if (!obj->is_smart) { - if (evas_object_is_in_output_rect(obj, + if (evas_object_is_in_output_rect(eo_obj, obj, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, 1, 1) && obj->cur.visible) - evas_event_feed_mouse_move(obj->layer->evas, + evas_event_feed_mouse_move(obj->layer->evas->evas, obj->layer->evas->pointer.x, obj->layer->evas->pointer.y, obj->layer->evas->last_timestamp, @@ -287,53 +317,91 @@ evas_object_stack_below(Evas_Object *obj, Evas_Object *below) } EAPI Evas_Object * -evas_object_above_get(const Evas_Object *obj) +evas_object_above_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object *ret = NULL; + eo_do((Eo *)eo_obj, evas_obj_above_get(&ret)); + return ret; +} + +void +_above_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Evas_Object **ret = va_arg(*list, Evas_Object **); + if (obj->smart.parent) { do { - obj = (Evas_Object *)((EINA_INLIST_GET(obj))->next); - if ((obj) && (!obj->delete_me)) return (Evas_Object *)obj; + obj = (Evas_Object_Protected_Data *)((EINA_INLIST_GET(obj))->next); + if ((obj) && (!obj->delete_me)) + { + *ret = obj->object; + return; + } } while (obj); - return NULL; + *ret = NULL; + return; } obj = evas_object_above_get_internal(obj); while (obj) { - if (!obj->delete_me) return (Evas_Object *)obj; + if (!obj->delete_me) + { + *ret = obj->object; + return; + } obj = evas_object_above_get_internal(obj); } - return NULL; + *ret = NULL; } EAPI Evas_Object * -evas_object_below_get(const Evas_Object *obj) +evas_object_below_get(const Evas_Object *eo_obj) { - MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); + MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); return NULL; MAGIC_CHECK_END(); + Evas_Object *ret = NULL; + eo_do((Eo *)eo_obj, evas_obj_below_get(&ret)); + return ret; +} + +void +_below_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +{ + const Evas_Object_Protected_Data *obj = _pd; + Evas_Object **ret = va_arg(*list, Evas_Object **); + *ret = NULL; if (obj->smart.parent) { do { - obj = (Evas_Object *)((EINA_INLIST_GET(obj))->prev); - if ((obj) && (!obj->delete_me)) return (Evas_Object *)obj; + obj = (Evas_Object_Protected_Data *)((EINA_INLIST_GET(obj))->prev); + if ((obj) && (!obj->delete_me)) + { + *ret = obj->object; + return; + } } while (obj); - return NULL; + return; } obj = evas_object_below_get_internal(obj); while (obj) { - if (!obj->delete_me) return (Evas_Object *)obj; + if (!obj->delete_me) + { + *ret = obj->object; + return; + } obj = evas_object_below_get_internal(obj); } - return NULL; } @@ -344,48 +412,76 @@ evas_object_bottom_get(const Evas *e) MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); + Evas_Object *ret = NULL; + eo_do((Eo *)e, evas_canvas_object_bottom_get(&ret)); + return ret; +} + +void +_canvas_object_bottom_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + Evas_Object **ret = va_arg(*list, Evas_Object **); + const Evas_Public_Data *e = _pd; if (e->layers) { - Evas_Object *obj; + Evas_Object_Protected_Data *obj; obj = e->layers->objects; while (obj) { - if (!obj->delete_me) return obj; + if (!obj->delete_me) + { + *ret = obj->object; + return; + } obj = evas_object_above_get_internal(obj); } } - return NULL; + *ret = NULL; } EAPI Evas_Object * -evas_object_top_get(const Evas *e) +evas_object_top_get(const Evas *eo_e) { - Evas_Object *obj = NULL; + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); + return NULL; + MAGIC_CHECK_END(); + Evas_Object *ret = NULL; + eo_do((Eo *)eo_e, evas_canvas_object_top_get(&ret)); + return ret; +} + +void +_canvas_object_top_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *params_list) +{ + Evas_Object **ret = va_arg(*params_list, Evas_Object **); + *ret = NULL; + Evas_Object_Protected_Data *obj = NULL; Eina_Inlist *list; Evas_Layer *layer; - MAGIC_CHECK(e, Evas, MAGIC_EVAS); - return NULL; - MAGIC_CHECK_END(); - + const Evas_Public_Data *e = _pd; list = EINA_INLIST_GET(e->layers); - if (!list) return NULL; + if (!list) return; layer = (Evas_Layer *) list->last; - if (!layer) return NULL; + if (!layer) return; list = EINA_INLIST_GET(layer->objects); - if (!list) return NULL; + if (!list) return; - obj = (Evas_Object *) list->last; - if (!obj) return NULL; + obj = (Evas_Object_Protected_Data *) list->last; + if (!obj) return; while (obj) { - if (!obj->delete_me) return obj; + if (!obj->delete_me) + { + *ret = obj->object; + return; + } obj = evas_object_below_get_internal(obj); } - return obj; + *ret = obj->object; } diff --git a/legacy/evas/src/lib/canvas/evas_touch_point.c b/legacy/evas/src/lib/canvas/evas_touch_point.c index bdea73fe31..603756a2f2 100644 --- a/legacy/evas/src/lib/canvas/evas_touch_point.c +++ b/legacy/evas/src/lib/canvas/evas_touch_point.c @@ -2,8 +2,9 @@ #include "evas_private.h" void -_evas_touch_point_append(Evas *e, int id, Evas_Coord x, Evas_Coord y) +_evas_touch_point_append(Evas *eo_e, int id, Evas_Coord x, Evas_Coord y) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Coord_Touch_Point *point; /* create new Evas_Coord_Touch_Point */ @@ -16,8 +17,9 @@ _evas_touch_point_append(Evas *e, int id, Evas_Coord x, Evas_Coord y) } void -_evas_touch_point_update(Evas *e, int id, Evas_Coord x, Evas_Coord y, Evas_Touch_Point_State state) +_evas_touch_point_update(Evas *eo_e, int id, Evas_Coord x, Evas_Coord y, Evas_Touch_Point_State state) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Eina_List *l; Evas_Coord_Touch_Point *point = NULL; @@ -34,8 +36,9 @@ _evas_touch_point_update(Evas *e, int id, Evas_Coord x, Evas_Coord y, Evas_Touch } void -_evas_touch_point_remove(Evas *e, int id) +_evas_touch_point_remove(Evas *eo_e, int id) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Eina_List *l; Evas_Coord_Touch_Point *point = NULL; @@ -51,25 +54,45 @@ _evas_touch_point_remove(Evas *e, int id) } EAPI unsigned int -evas_touch_point_list_count(Evas *e) +evas_touch_point_list_count(Evas *eo_e) { - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return 0; MAGIC_CHECK_END(); - return eina_list_count(e->touch_points); + unsigned int ret = 0; + eo_do((Eo *)eo_e, evas_canvas_touch_point_list_count(&ret)); + return ret; +} + +void +_canvas_touch_point_list_count(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + unsigned int *ret = va_arg(*list, unsigned int *); + const Evas_Public_Data *e = _pd; + *ret = eina_list_count(e->touch_points); } EAPI void -evas_touch_point_list_nth_xy_get(Evas *e, unsigned int n, Evas_Coord *x, Evas_Coord *y) +evas_touch_point_list_nth_xy_get(Evas *eo_e, unsigned int n, Evas_Coord *x, Evas_Coord *y) { - Evas_Coord_Touch_Point *point = NULL; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); if (x) *x = 0; if (y) *y = 0; return; MAGIC_CHECK_END(); + eo_do(eo_e, evas_canvas_touch_point_list_nth_xy_get(n, x, y)); +} +void +_canvas_touch_point_list_nth_xy_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + unsigned int n = va_arg(*list, unsigned int); + Evas_Coord *x = va_arg(*list, Evas_Coord *); + Evas_Coord *y = va_arg(*list, Evas_Coord *); + + Evas_Coord_Touch_Point *point = NULL; + + Evas_Public_Data *e = _pd; point = (Evas_Coord_Touch_Point *)eina_list_nth(e->touch_points, n); if (!point) { @@ -82,29 +105,51 @@ evas_touch_point_list_nth_xy_get(Evas *e, unsigned int n, Evas_Coord *x, Evas_Co } EAPI int -evas_touch_point_list_nth_id_get(Evas *e, unsigned int n) +evas_touch_point_list_nth_id_get(Evas *eo_e, unsigned int n) { - Evas_Coord_Touch_Point *point = NULL; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return -1; MAGIC_CHECK_END(); + int ret = -1; + eo_do(eo_e, evas_canvas_touch_point_list_nth_id_get(n, &ret)); + return ret; +} +void +_canvas_touch_point_list_nth_id_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + unsigned int n = va_arg(*list, unsigned int); + int *ret = va_arg(*list, int *); + + Evas_Coord_Touch_Point *point = NULL; + + Evas_Public_Data *e = _pd; point = (Evas_Coord_Touch_Point *)eina_list_nth(e->touch_points, n); - if (!point) return -1; - return point->id; + if (!point) *ret = -1; + else *ret = point->id; } EAPI Evas_Touch_Point_State -evas_touch_point_list_nth_state_get(Evas *e, unsigned int n) +evas_touch_point_list_nth_state_get(Evas *eo_e, unsigned int n) { - Evas_Coord_Touch_Point *point = NULL; - - MAGIC_CHECK(e, Evas, MAGIC_EVAS); + MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS); return EVAS_TOUCH_POINT_CANCEL; MAGIC_CHECK_END(); - - point = (Evas_Coord_Touch_Point *)eina_list_nth(e->touch_points, n); - if (!point) return EVAS_TOUCH_POINT_CANCEL; - return point->state; + Evas_Touch_Point_State ret = EVAS_TOUCH_POINT_CANCEL; + eo_do(eo_e, evas_canvas_touch_point_list_nth_state_get(n, &ret)); + return ret; +} + +void +_canvas_touch_point_list_nth_state_get(Eo *eo_e EINA_UNUSED, void *_pd, va_list *list) +{ + unsigned int n = va_arg(*list, unsigned int); + Evas_Touch_Point_State *ret = va_arg(*list, Evas_Touch_Point_State *); + + Evas_Coord_Touch_Point *point = NULL; + + Evas_Public_Data *e = _pd; + point = (Evas_Coord_Touch_Point *)eina_list_nth(e->touch_points, n); + if (!point) *ret = EVAS_TOUCH_POINT_CANCEL; + else *ret = point->state; } diff --git a/legacy/evas/src/lib/include/evas_inline.x b/legacy/evas/src/lib/include/evas_inline.x index 44e24cea65..b9ae608af6 100644 --- a/legacy/evas/src/lib/include/evas_inline.x +++ b/legacy/evas/src/lib/include/evas_inline.x @@ -2,9 +2,10 @@ #define EVAS_INLINE_H static inline Eina_Bool -_evas_render_has_map(Evas_Object *obj) +_evas_render_has_map(Evas_Object *eo_obj) { - return ((!((obj->func->can_map) && (obj->func->can_map(obj)))) && + Evas_Object_Protected_Data *obj = eo_data_get(eo_obj, EVAS_OBJ_CLASS); + return ((!((obj->func->can_map) && (obj->func->can_map(eo_obj)))) && ((obj->cur.map) && (obj->cur.usemap))); // return ((obj->cur.map) && (obj->cur.usemap)); } @@ -16,15 +17,15 @@ _evas_object_event_new(void) } static inline int -evas_object_was_visible(Evas_Object *obj) +evas_object_was_visible(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { if ((obj->prev.visible) && - ((obj->prev.cache.clip.visible) || (obj->smart.smart)) && + ((obj->prev.cache.clip.visible) || obj->is_smart) && ((obj->prev.cache.clip.a > 0 && obj->prev.render_op == EVAS_RENDER_BLEND) || obj->prev.render_op != EVAS_RENDER_BLEND)) { if (obj->func->was_visible) - return obj->func->was_visible(obj); + return obj->func->was_visible(eo_obj); return 1; } return 0; @@ -62,15 +63,15 @@ evas_common_draw_context_cutouts_add(Cutout_Rects* rects, } static inline int -evas_object_is_opaque(Evas_Object *obj) +evas_object_is_opaque(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - if (obj->smart.smart) return 0; + if (obj->is_smart) return 0; /* If a mask: Assume alpha */ if (obj->cur.mask) return 0; if (obj->cur.cache.clip.a == 255) { if (obj->func->is_opaque) - return obj->func->is_opaque(obj); + return obj->func->is_opaque(eo_obj, obj); return 1; } if (obj->cur.render_op == EVAS_RENDER_COPY) @@ -79,60 +80,66 @@ evas_object_is_opaque(Evas_Object *obj) } static inline int -evas_event_freezes_through(Evas_Object *obj) +evas_event_freezes_through(Evas_Object *eo_obj __UNUSED__, Evas_Object_Protected_Data *obj) { if (obj->freeze_events) return 1; if (obj->parent_cache.freeze_events_valid) return obj->parent_cache.freeze_events; if (!obj->smart.parent) return 0; + Evas_Object_Protected_Data *smart_parent_pd = eo_data_get(obj->smart.parent, EVAS_OBJ_CLASS); obj->parent_cache.freeze_events = - evas_event_freezes_through(obj->smart.parent); + evas_event_freezes_through(obj->smart.parent, smart_parent_pd); obj->parent_cache.freeze_events_valid = EINA_TRUE; return obj->parent_cache.freeze_events; } static inline int -evas_event_passes_through(Evas_Object *obj) +evas_event_passes_through(Evas_Object *eo_obj __UNUSED__, Evas_Object_Protected_Data *obj) { if (obj->pass_events) return 1; if (obj->parent_cache.pass_events_valid) return obj->parent_cache.pass_events; if (!obj->smart.parent) return 0; + Evas_Object_Protected_Data *smart_parent_pd = eo_data_get(obj->smart.parent, EVAS_OBJ_CLASS); obj->parent_cache.pass_events = - evas_event_passes_through(obj->smart.parent); + evas_event_passes_through(obj->smart.parent, smart_parent_pd); obj->parent_cache.pass_events_valid = EINA_TRUE; return obj->parent_cache.pass_events; } static inline int -evas_object_is_visible(Evas_Object *obj) +evas_object_is_visible(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { /* post 1.0 -> enable? */ if ((obj->cur.visible)/* && (obj->cur.color.a > 0)*/ && - ((obj->cur.cache.clip.visible) || (obj->smart.smart)) && + ((obj->cur.cache.clip.visible) || (obj->is_smart)) && ((obj->cur.cache.clip.a > 0 && obj->cur.render_op == EVAS_RENDER_BLEND) || obj->cur.render_op != EVAS_RENDER_BLEND)) { if (obj->func->is_visible) - return obj->func->is_visible(obj); + return obj->func->is_visible(eo_obj); return 1; } return 0; } static inline int -evas_object_clippers_is_visible(Evas_Object *obj) +evas_object_clippers_is_visible(Evas_Object *eo_obj __UNUSED__, Evas_Object_Protected_Data *obj) { if (obj->cur.visible) { + Evas_Object_Protected_Data *clipper_pd = NULL; if (obj->cur.clipper) - return evas_object_clippers_is_visible(obj->cur.clipper); + { + clipper_pd = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + return evas_object_clippers_is_visible(obj->cur.clipper, clipper_pd); + } return 1; } return 0; } static inline int -evas_object_is_in_output_rect(Evas_Object *obj, int x, int y, int w, int h) +evas_object_is_in_output_rect(Evas_Object *eo_obj __UNUSED__, Evas_Object_Protected_Data *obj, int x, int y, int w, int h) { /* assumes coords have been recalced */ if ((RECTS_INTERSECT(x, y, w, h, @@ -145,26 +152,26 @@ evas_object_is_in_output_rect(Evas_Object *obj, int x, int y, int w, int h) } static inline int -evas_object_is_active(Evas_Object *obj) +evas_object_is_active(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - if (evas_object_is_visible(obj) || evas_object_was_visible(obj)) + if (evas_object_is_visible(eo_obj, obj) || evas_object_was_visible(eo_obj, obj)) { - if (obj->smart.smart) + if (obj->is_smart) { int mapsmt = 0; - if (obj->smart.smart && (obj->cur.map && obj->cur.usemap)) mapsmt = 1; + if (obj->cur.map && obj->cur.usemap) mapsmt = 1; if (!mapsmt) return 1; - if (evas_object_is_in_output_rect(obj, 0, 0, obj->layer->evas->output.w, + if (evas_object_is_in_output_rect(eo_obj, obj, 0, 0, obj->layer->evas->output.w, obj->layer->evas->output.h) || - evas_object_was_in_output_rect(obj, 0, 0, obj->layer->evas->output.w, + evas_object_was_in_output_rect(eo_obj, obj, 0, 0, obj->layer->evas->output.w, obj->layer->evas->output.h)) return 1; } else { - if (evas_object_is_in_output_rect(obj, 0, 0, obj->layer->evas->output.w, + if (evas_object_is_in_output_rect(eo_obj, obj, 0, 0, obj->layer->evas->output.w, obj->layer->evas->output.h) || - evas_object_was_in_output_rect(obj, 0, 0, obj->layer->evas->output.w, + evas_object_was_in_output_rect(eo_obj, obj, 0, 0, obj->layer->evas->output.w, obj->layer->evas->output.h)) return 1; } @@ -177,7 +184,7 @@ evas_object_is_active(Evas_Object *obj) } static inline void -evas_object_coords_recalc(Evas_Object *obj) +evas_object_coords_recalc(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { //// if (obj->cur.cache.geometry.validity == obj->layer->evas->output_validity) //// return; @@ -191,23 +198,27 @@ evas_object_coords_recalc(Evas_Object *obj) //// obj->cur.cache.geometry.h = //// evas_coord_world_y_to_screen(obj->layer->evas, obj->cur.geometry.h) - //// evas_coord_world_y_to_screen(obj->layer->evas, 0); - if (obj->func->coords_recalc) obj->func->coords_recalc(obj); + if (obj->func->coords_recalc) obj->func->coords_recalc(eo_obj, obj); //// obj->cur.cache.geometry.validity = obj->layer->evas->output_validity; } static inline void -evas_object_clip_recalc(Evas_Object *obj) +evas_object_clip_recalc(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { int cx, cy, cw, ch, cr, cg, cb, ca; int nx, ny, nw, nh, nr, ng, nb, na; Eina_Bool cvis, nvis; + Evas_Object_Protected_Data *clipper = NULL; + if (obj->cur.clipper) + clipper = eo_data_get(obj->cur.clipper, EVAS_OBJ_CLASS); + if ((!obj->cur.cache.clip.dirty) && - !(!obj->cur.clipper || obj->cur.clipper->cur.cache.clip.dirty)) return; + !(!obj->cur.clipper || clipper->cur.cache.clip.dirty)) return; - if (obj->layer->evas->events_frozen > 0) return; + if (obj->layer->evas->is_frozen) return; - evas_object_coords_recalc(obj); + evas_object_coords_recalc(eo_obj, obj); if ((obj->cur.map) && (obj->cur.usemap)) { @@ -225,7 +236,7 @@ evas_object_clip_recalc(Evas_Object *obj) } if (obj->cur.color.a == 0 && obj->cur.render_op == EVAS_RENDER_BLEND) - cvis = EINA_FALSE; + cvis = EINA_FALSE; else cvis = obj->cur.visible; cr = obj->cur.color.r; cg = obj->cur.color.g; @@ -234,26 +245,26 @@ evas_object_clip_recalc(Evas_Object *obj) if (obj->cur.clipper) { // this causes problems... hmmm ????? - if (obj->cur.clipper->cur.cache.clip.dirty) - evas_object_clip_recalc(obj->cur.clipper); + if (clipper->cur.cache.clip.dirty) + evas_object_clip_recalc(obj->cur.clipper, clipper); // I don't know why this test was here in the first place. As I have // no issue showing up due to this, I keep it and move color out of it. // breaks cliping of mapped images!!! - if (obj->cur.clipper->cur.map_parent == obj->cur.map_parent) + if (clipper->cur.map_parent == obj->cur.map_parent) { - nx = obj->cur.clipper->cur.cache.clip.x; - ny = obj->cur.clipper->cur.cache.clip.y; - nw = obj->cur.clipper->cur.cache.clip.w; - nh = obj->cur.clipper->cur.cache.clip.h; + nx = clipper->cur.cache.clip.x; + ny = clipper->cur.cache.clip.y; + nw = clipper->cur.cache.clip.w; + nh = clipper->cur.cache.clip.h; RECTS_CLIP_TO_RECT(cx, cy, cw, ch, nx, ny, nw, nh); } - nvis = obj->cur.clipper->cur.cache.clip.visible; - nr = obj->cur.clipper->cur.cache.clip.r; - ng = obj->cur.clipper->cur.cache.clip.g; - nb = obj->cur.clipper->cur.cache.clip.b; - na = obj->cur.clipper->cur.cache.clip.a; + nvis = clipper->cur.cache.clip.visible; + nr = clipper->cur.cache.clip.r; + ng = clipper->cur.cache.clip.g; + nb = clipper->cur.cache.clip.b; + na = clipper->cur.cache.clip.a; cvis = (cvis & nvis); cr = (cr * (nr + 1)) >> 8; cg = (cg * (ng + 1)) >> 8; diff --git a/legacy/evas/src/lib/include/evas_private.h b/legacy/evas/src/lib/include/evas_private.h index 62f925c5c3..283d376a17 100644 --- a/legacy/evas/src/lib/include/evas_private.h +++ b/legacy/evas/src/lib/include/evas_private.h @@ -128,11 +128,9 @@ OPAQUE_TYPE(Evas_Font_Instance); /* General type for RGBA_Font_Int */ # define MAGIC_CHECK_FAILED(o, t, m) \ {evas_debug_error(); \ if (!o) evas_debug_input_null(); \ - else if (((t *)o)->magic == 0) evas_debug_magic_null(); \ - else evas_debug_magic_wrong((m), ((t *)o)->magic); \ } # define MAGIC_CHECK(o, t, m) \ -{if (EINA_UNLIKELY((!o) || (!(((t *)o)->magic == (m))))) { \ +{if (EINA_UNLIKELY(!o)) { \ MAGIC_CHECK_FAILED(o, t, m) # define MAGIC_CHECK_END() }} #else @@ -255,6 +253,16 @@ struct _Evas_Smart_Interfaces_Array const Evas_Smart_Interface **array; }; +/** + * @def evas_obj_smart_attach + * + * Attach a given smart data to a given smart object. + * + * @param[in] s in + * + */ +#define evas_obj_smart_attach(s) EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ATTACH), EO_TYPECHECK(Evas_Smart *, s) + struct _Evas_Smart { DATA32 magic; @@ -304,11 +312,12 @@ struct _Evas_Callbacks unsigned char deletions_waiting : 1; }; -struct _Evas +struct _Evas_Public_Data { EINA_INLIST; DATA32 magic; + Evas *evas; struct { unsigned char inside : 1; @@ -350,7 +359,6 @@ struct _Evas int output_validity; int walking_list; - int events_frozen; Evas_Event_Flags default_event_flags; struct { @@ -383,6 +391,7 @@ struct _Evas Eina_List *post_events; // free me on evas_free Evas_Callbacks *callbacks; + Eina_Inlist *callbacks_infos; int delete_grabs; int walking_grabs; @@ -407,6 +416,7 @@ struct _Evas unsigned char invalidate : 1; unsigned char cleanup : 1; unsigned char focus : 1; + Eina_Bool is_frozen : 1; Eina_List *touch_points; Eina_List *devices; @@ -418,9 +428,9 @@ struct _Evas_Layer EINA_INLIST; short layer; - Evas_Object *objects; + Evas_Object_Protected_Data *objects; - Evas *evas; + Evas_Public_Data *evas; void *engine_data; int usage; @@ -509,12 +519,10 @@ EAPI Evas_Software_Filter_Fn evas_filter_software_get(Evas_Filter_Info *info); void evas_filter_free(Evas_Object *o); #endif -struct _Evas_Object +struct _Evas_Object_Protected_Data { EINA_INLIST; - DATA32 magic; - const char *type; Evas_Layer *layer; @@ -575,8 +583,6 @@ struct _Evas_Object const Evas_Object_Func *func; - void *object_data; - struct { Evas_Smart *smart; Evas_Object *parent; @@ -589,6 +595,8 @@ struct _Evas_Object Eina_Bool redraw; } proxy; + // Pointer to the Evas_Object itself + Evas_Object *object; #if 0 // filtering disabled Evas_Filter_Info *filter; #endif @@ -601,6 +609,8 @@ struct _Evas_Object int last_mouse_up_counter; int mouse_grabbed; + // Daniel: Added because the destructor can't take parameters, at least for the moment + int clean_layer; int last_event; Evas_Callback_Type last_event_type; @@ -613,6 +623,7 @@ struct _Evas_Object void **interface_privates; unsigned int ref; + Eina_List *supported_types; unsigned char delete_me; @@ -654,6 +665,8 @@ struct _Evas_Object Eina_Bool is_frame : 1; Eina_Bool child_has_map : 1; + Eina_Bool eo_del_called : 1; + Eina_Bool is_smart : 1; }; struct _Evas_Func_Node @@ -730,10 +743,10 @@ struct _Evas_Device struct _Evas_Object_Func { - void (*free) (Evas_Object *obj); - void (*render) (Evas_Object *obj, void *output, void *context, void *surface, int x, int y); - void (*render_pre) (Evas_Object *obj); - void (*render_post) (Evas_Object *obj); + void (*free) (Evas_Object *obj, Evas_Object_Protected_Data *pd); + void (*render) (Evas_Object *obj, Evas_Object_Protected_Data *pd, void *output, void *context, void *surface, int x, int y); + void (*render_pre) (Evas_Object *obj, Evas_Object_Protected_Data *pd); + void (*render_post) (Evas_Object *obj, Evas_Object_Protected_Data *pd); unsigned int (*type_id_get) (Evas_Object *obj); unsigned int (*visual_id_get) (Evas_Object *obj); @@ -745,18 +758,18 @@ struct _Evas_Object_Func int (*is_visible) (Evas_Object *obj); int (*was_visible) (Evas_Object *obj); - int (*is_opaque) (Evas_Object *obj); - int (*was_opaque) (Evas_Object *obj); + int (*is_opaque) (Evas_Object *obj, Evas_Object_Protected_Data *pd); + int (*was_opaque) (Evas_Object *obj, Evas_Object_Protected_Data *pd); - int (*is_inside) (Evas_Object *obj, Evas_Coord x, Evas_Coord y); - int (*was_inside) (Evas_Object *obj, Evas_Coord x, Evas_Coord y); + int (*is_inside) (Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Coord x, Evas_Coord y); + int (*was_inside) (Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Coord x, Evas_Coord y); - void (*coords_recalc) (Evas_Object *obj); + void (*coords_recalc) (Evas_Object *obj, Evas_Object_Protected_Data *pd); void (*scale_update) (Evas_Object *obj); - int (*has_opaque_rect) (Evas_Object *obj); - int (*get_opaque_rect) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h); + int (*has_opaque_rect) (Evas_Object *obj, Evas_Object_Protected_Data *pd); + int (*get_opaque_rect) (Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h); int (*can_map) (Evas_Object *obj); }; @@ -931,6 +944,13 @@ struct _Evas_Image_Save_Func int (*image_save) (RGBA_Image *im, const char *file, const char *key, int quality, int compress); }; + +typedef struct +{ + Eo_Event_Description *eo_desc; + Eina_Bool is_desc_allocated : 1; +} _Evas_Event_Description; + #ifdef __cplusplus extern "C" { #endif @@ -939,19 +959,19 @@ Evas_Object *evas_object_new(Evas *e); void evas_object_change_reset(Evas_Object *obj); void evas_object_cur_prev(Evas_Object *obj); void evas_object_free(Evas_Object *obj, int clean_layer); -void evas_object_update_bounding_box(Evas_Object *obj); -void evas_object_inject(Evas_Object *obj, Evas *e); -void evas_object_release(Evas_Object *obj, int clean_layer); -void evas_object_change(Evas_Object *obj); +void evas_object_update_bounding_box(Evas_Object *obj, Evas_Object_Protected_Data *pd); +void evas_object_inject(Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas *e); +void evas_object_release(Evas_Object *obj, Evas_Object_Protected_Data *pd, int clean_layer); +void evas_object_change(Evas_Object *obj, Evas_Object_Protected_Data *pd); void evas_object_clip_changes_clean(Evas_Object *obj); void evas_object_render_pre_visible_change(Eina_Array *rects, Evas_Object *obj, int is_v, int was_v); void evas_object_render_pre_clipper_change(Eina_Array *rects, Evas_Object *obj); -void evas_object_render_pre_prev_cur_add(Eina_Array *rects, Evas_Object *obj); +void evas_object_render_pre_prev_cur_add(Eina_Array *rects, Evas_Object *obj, Evas_Object_Protected_Data *pd); void evas_object_render_pre_effect_updates(Eina_Array *rects, Evas_Object *obj, int is_v, int was_v); void evas_rects_return_difference_rects(Eina_Array *rects, int x, int y, int w, int h, int xx, int yy, int ww, int hh); -void evas_object_clip_dirty(Evas_Object *obj); -void evas_object_recalc_clippees(Evas_Object *obj); +void evas_object_clip_dirty(Evas_Object *obj, Evas_Object_Protected_Data *pd); +void evas_object_recalc_clippees(Evas_Object *obj, Evas_Object_Protected_Data *pd); Evas_Layer *evas_layer_new(Evas *e); void evas_layer_pre_free(Evas_Layer *lay); void evas_layer_free_objects(Evas_Layer *lay); @@ -960,17 +980,17 @@ Evas_Layer *evas_layer_find(Evas *e, short layer_num); void evas_layer_add(Evas_Layer *lay); void evas_layer_del(Evas_Layer *lay); -int evas_object_was_in_output_rect(Evas_Object *obj, int x, int y, int w, int h); +int evas_object_was_in_output_rect(Evas_Object *obj, Evas_Object_Protected_Data *pd, int x, int y, int w, int h); -int evas_object_was_opaque(Evas_Object *obj); -int evas_object_is_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); -int evas_object_was_inside(Evas_Object *obj, Evas_Coord x, Evas_Coord y); -int evas_object_clippers_was_visible(Evas_Object *obj); -void evas_object_clip_across_check(Evas_Object *obj); -void evas_object_clip_across_clippees_check(Evas_Object *obj); -void evas_object_mapped_clip_across_mark(Evas_Object *obj); +int evas_object_was_opaque(Evas_Object *obj, Evas_Object_Protected_Data *pd); +int evas_object_is_inside(Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Coord x, Evas_Coord y); +int evas_object_was_inside(Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Coord x, Evas_Coord y); +int evas_object_clippers_was_visible(Evas_Object *obj, Evas_Object_Protected_Data *pd); +void evas_object_clip_across_check(Evas_Object *obj, Evas_Object_Protected_Data *pd); +void evas_object_clip_across_clippees_check(Evas_Object *obj, Evas_Object_Protected_Data *pd); +void evas_object_mapped_clip_across_mark(Evas_Object *obj, Evas_Object_Protected_Data *pd); void evas_event_callback_call(Evas *e, Evas_Callback_Type type, void *event_info); -void evas_object_event_callback_call(Evas_Object *obj, Evas_Callback_Type type, void *event_info, int event_id); +void evas_object_event_callback_call(Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Callback_Type type, void *event_info, int event_id); Eina_List *evas_event_objects_event_list(Evas *e, Evas_Object *stop, int x, int y); int evas_mem_free(int mem_required); int evas_mem_degrade(int mem_required); @@ -1004,7 +1024,7 @@ void evas_call_smarts_calculate(Evas *e); void evas_object_smart_bouding_box_update(Evas_Object *obj); void evas_object_smart_need_bounding_box_update(Evas_Object *obj); void *evas_mem_calloc(int size); -void _evas_post_event_callback_call(Evas *e); +void _evas_post_event_callback_call(Evas *e, Evas_Public_Data* e_pd); void _evas_post_event_callback_free(Evas *e); void evas_event_callback_list_post_free(Eina_Inlist **list); void evas_object_event_callback_all_del(Evas_Object *obj); @@ -1013,7 +1033,7 @@ void evas_event_callback_all_del(Evas *e); void evas_event_callback_cleanup(Evas *e); void evas_object_inform_call_show(Evas_Object *obj); void evas_object_inform_call_hide(Evas_Object *obj); -void evas_object_inform_call_move(Evas_Object *obj); +void evas_object_inform_call_move(Evas_Object *obj, Evas_Object_Protected_Data *pd); void evas_object_inform_call_resize(Evas_Object *obj); void evas_object_inform_call_restack(Evas_Object *obj); void evas_object_inform_call_changed_size_hints(Evas_Object *obj); @@ -1023,7 +1043,7 @@ void evas_object_inform_call_image_resize(Evas_Object *obj); void evas_object_intercept_cleanup(Evas_Object *obj); int evas_object_intercept_call_show(Evas_Object *obj); int evas_object_intercept_call_hide(Evas_Object *obj); -int evas_object_intercept_call_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y); +int evas_object_intercept_call_move(Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Coord x, Evas_Coord y); int evas_object_intercept_call_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h); int evas_object_intercept_call_raise(Evas_Object *obj); int evas_object_intercept_call_lower(Evas_Object *obj); @@ -1031,10 +1051,10 @@ int evas_object_intercept_call_stack_above(Evas_Object *obj, Evas_Object *above) int evas_object_intercept_call_stack_below(Evas_Object *obj, Evas_Object *below); int evas_object_intercept_call_layer_set(Evas_Object *obj, int l); int evas_object_intercept_call_color_set(Evas_Object *obj, int r, int g, int b, int a); -int evas_object_intercept_call_clip_set(Evas_Object *obj, Evas_Object *clip); +int evas_object_intercept_call_clip_set(Evas_Object *obj, Evas_Object_Protected_Data *pd, Evas_Object *clip); int evas_object_intercept_call_clip_unset(Evas_Object *obj); -void evas_object_grabs_cleanup(Evas_Object *obj); -void evas_key_grab_free(Evas_Object *obj, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers); +void evas_object_grabs_cleanup(Evas_Object *obj, Evas_Object_Protected_Data *pd); +void evas_key_grab_free(Evas_Object *obj, Evas_Object_Protected_Data *pd, const char *keyname, Evas_Modifier_Mask modifiers, Evas_Modifier_Mask not_modifiers); void evas_font_dir_cache_free(void); const char *evas_font_dir_cache_find(char *dir, char *font); Eina_List *evas_font_dir_available_list(const Evas* evas); @@ -1056,6 +1076,123 @@ void evas_text_style_pad_get(Evas_Text_Style_Type style, int *l, int *r, int *t, void _evas_object_text_rehint(Evas_Object *obj); void _evas_object_textblock_rehint(Evas_Object *obj); + +void _freeze_events_set(Eo *obj, void *_pd, va_list *list); +void _freeze_events_get(Eo *obj, void *_pd, va_list *list); +void _pass_events_set(Eo *obj, void *_pd, va_list *list); +void _pass_events_get(Eo *obj, void *_pd, va_list *list); +void _repeat_events_set(Eo *obj, void *_pd, va_list *list); +void _repeat_events_get(Eo *obj, void *_pd, va_list *list); +void _propagate_events_set(Eo *obj, void *_pd, va_list *list); +void _propagate_events_get(Eo *obj, void *_pd, va_list *list); +void _pointer_mode_set(Eo *obj, void *_pd, va_list *list); +void _pointer_mode_get(Eo *obj, void *_pd, va_list *list); +void _key_grab(Eo *obj, void *_pd, va_list *list); +void _key_ungrab(Eo *obj, void *_pd, va_list *list); +void _focus_set(Eo *obj, void *_pd, va_list *list); +void _focus_get(Eo *obj, void *_pd, va_list *list); +void _name_set(Eo *obj, void *_pd, va_list *list); +void _name_get(Eo *obj, void *_pd, va_list *list); +void _name_child_find(Eo *obj, void *_pd, va_list *list); +void _layer_set(Eo *obj, void *_pd, va_list *list); +void _layer_get(Eo *obj, void *_pd, va_list *list); +void _clip_set(Eo *obj, void *_pd, va_list *list); +void _clip_get(Eo *obj, void *_pd, va_list *list); +void _clip_unset(Eo *obj, void *_pd, va_list *list); +void _clipees_get(Eo *obj, void *_pd, va_list *list); +void _map_enable_set(Eo *obj, void *_pd, va_list *list); +void _map_enable_get(Eo *obj, void *_pd, va_list *list); +void _map_source_set(Eo *obj, void *_pd, va_list *list); +void _map_source_get(Eo *obj, void *_pd, va_list *list); +void _map_set(Eo *obj, void *_pd, va_list *list); +void _map_get(Eo *obj, void *_pd, va_list *list); +void _raise(Eo *obj, void *_pd, va_list *list); +void _lower(Eo *obj, void *_pd, va_list *list); +void _stack_above(Eo *obj, void *_pd, va_list *list); +void _stack_below(Eo *obj, void *_pd, va_list *list); +void _above_get(Eo *obj, void *_pd, va_list *list); +void _below_get(Eo *obj, void *_pd, va_list *list); +void _smart_move_children_relative(Eo *obj, void *_pd, va_list *list); +void _smart_clipped_clipper_get(Eo *obj, void *_pd, va_list *list); + +void _canvas_event_default_flags_set(Eo *e, void *_pd, va_list *list); +void _canvas_event_default_flags_get(Eo *e, void *_pd, va_list *list); +void _canvas_event_freeze(Eo *e, void *_pd, va_list *list); +void _canvas_event_thaw(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_down(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_up(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_cancel(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_wheel(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_move(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_in(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_mouse_out(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_multi_down(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_multi_up(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_multi_move(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_key_down(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_key_up(Eo *e, void *_pd, va_list *list); +void _canvas_event_feed_hold(Eo *e, void *_pd, va_list *list); +void _canvas_event_refeed_event(Eo *e, void *_pd, va_list *list); +void _canvas_event_down_count_get(Eo *e, void *_pd, va_list *list); +void _canvas_focus_get(Eo *e, void *_pd, va_list *list); +void _canvas_font_path_clear(Eo *e, void *_pd, va_list *list); +void _canvas_font_path_append(Eo *e, void *_pd, va_list *list); +void _canvas_font_path_prepend(Eo *e, void *_pd, va_list *list); +void _canvas_font_path_list(Eo *e, void *_pd, va_list *list); +void _canvas_font_hinting_set(Eo *e, void *_pd, va_list *list); +void _canvas_font_hinting_get(Eo *e, void *_pd, va_list *list); +void _canvas_font_hinting_can_hint(Eo *e, void *_pd, va_list *list); +void _canvas_font_cache_flush(Eo *e, void *_pd, va_list *list); +void _canvas_font_cache_set(Eo *e, void *_pd, va_list *list); +void _canvas_font_cache_get(Eo *e, void *_pd, va_list *list); +void _canvas_font_available_list(Eo *e, void *_pd, va_list *list); + +void _canvas_key_modifier_get(Eo *e, void *_pd, va_list *list); +void _canvas_key_lock_get(Eo *e, void *_pd, va_list *list); +void _canvas_key_modifier_add(Eo *e, void *_pd, va_list *list); +void _canvas_key_modifier_del(Eo *e, void *_pd, va_list *list); +void _canvas_key_lock_add(Eo *e, void *_pd, va_list *list); +void _canvas_key_lock_del(Eo *e, void *_pd, va_list *list); +void _canvas_key_modifier_on(Eo *e, void *_pd, va_list *list); +void _canvas_key_modifier_off(Eo *e, void *_pd, va_list *list); +void _canvas_key_lock_on(Eo *e, void *_pd, va_list *list); +void _canvas_key_lock_off(Eo *e, void *_pd, va_list *list); +void _canvas_key_modifier_mask_get(Eo *e, void *_pd, va_list *list); + +void _canvas_damage_rectangle_add(Eo *obj, void *_pd, va_list *list); +void _canvas_obscured_rectangle_add(Eo *obj, void *_pd, va_list *list); +void _canvas_obscured_clear(Eo *obj, void *_pd, va_list *list); +void _canvas_render_updates(Eo *obj, void *_pd, va_list *list); +void _canvas_render(Eo *e, void *_pd, va_list *list); +void _canvas_norender(Eo *e, void *_pd, va_list *list); +void _canvas_render_idle_flush(Eo *e, void *_pd, va_list *list); +void _canvas_sync(Eo *obj, void *_pd, va_list *list); +void _canvas_render_dump(Eo *obj, void *_pd, va_list *list); + +void _canvas_object_bottom_get(Eo *e, void *_pd, va_list *list); +void _canvas_object_top_get(Eo *e, void *_pd, va_list *list); + +void _canvas_touch_point_list_count(Eo *obj, void *_pd, va_list *list); +void _canvas_touch_point_list_nth_xy_get(Eo *obj, void *_pd, va_list *list); +void _canvas_touch_point_list_nth_id_get(Eo *obj, void *_pd, va_list *list); +void _canvas_touch_point_list_nth_state_get(Eo *obj, void *_pd, va_list *list); + +void _canvas_image_cache_flush(Eo *e, void *_pd, va_list *list); +void _canvas_image_cache_reload(Eo *e, void *_pd, va_list *list); +void _canvas_image_cache_set(Eo *e, void *_pd, va_list *list); +void _canvas_image_cache_get(Eo *e, void *_pd, va_list *list); +void _canvas_image_max_size_get(Eo *e, void *_pd, va_list *list); + +void _canvas_object_name_find(Eo *e, void *_pd, va_list *list); + +void _canvas_object_top_at_xy_get(Eo *e, void *_pd, va_list *list); +void _canvas_object_top_in_rectangle_get(Eo *e, void *_pd, va_list *list); +void _canvas_objects_at_xy_get(Eo *e, void *_pd, va_list *list); +void _canvas_objects_in_rectangle_get(Eo *obj, void *_pd, va_list *list); + +void _canvas_smart_objects_calculate(Eo *e, void *_pd, va_list *list); +void _canvas_smart_objects_calculate_count_get(Eo *e, void *_pd, va_list *list); + extern int _evas_alloc_error; extern int _evas_event_counter; @@ -1081,14 +1218,14 @@ Evas_Preload_Pthread *evas_preload_thread_run(void (*func_heavy)(void *data), const void *data); Eina_Bool evas_preload_thread_cancel(Evas_Preload_Pthread *thread); -void _evas_walk(Evas *e); -void _evas_unwalk(Evas *e); +void _evas_walk(Evas_Public_Data *e_pd); +void _evas_unwalk(Evas_Public_Data *e_pd); // expose for use in engines EAPI int _evas_module_engine_inherit(Evas_Func *funcs, char *name); EAPI const char *_evas_module_libdir_get(void); -Eina_Bool evas_render_mapped(Evas *e, Evas_Object *obj, +Eina_Bool evas_render_mapped(Evas *e, Evas_Object *obj, Evas_Object_Protected_Data *source_pd, void *context, void *surface, int off_x, int off_y, int mapped, int ecx, int ecy, int ecw, int ech diff --git a/legacy/evas/src/modules/engines/buffer/evas_engine.c b/legacy/evas/src/modules/engines/buffer/evas_engine.c index 371c78361e..3e12a7e77b 100644 --- a/legacy/evas/src/modules/engines/buffer/evas_engine.c +++ b/legacy/evas/src/modules/engines/buffer/evas_engine.c @@ -32,9 +32,9 @@ struct _Render_Engine /* prototypes we will use here */ static void *_output_setup(int w, int h, void *dest_buffer, int dest_buffer_row_bytes, int depth_type, int use_color_key, int alpha_threshold, int color_key_r, int color_key_g, int color_key_b, void *(*new_update_region) (int x, int y, int w, int h, int *row_bytes), void (*free_update_region) (int x, int y, int w, int h, void *data), void *(*switch_buffer) (void *data, void *dest_buffer), void *switch_data); -static void *eng_info(Evas *e __UNUSED__); -static void eng_info_free(Evas *e __UNUSED__, void *info); -static int eng_setup(Evas *e, void *info); +static void *eng_info(Evas *eo_e __UNUSED__); +static void eng_info_free(Evas *eo_e __UNUSED__, void *info); +static int eng_setup(Evas *eo_e, void *info); static void eng_output_free(void *data); static void eng_output_resize(void *data, int w, int h); static void eng_output_tile_size_set(void *data, int w, int h); @@ -125,7 +125,7 @@ _output_setup(int w, /* engine api this module provides */ static void * -eng_info(Evas *e __UNUSED__) +eng_info(Evas *eo_e __UNUSED__) { Evas_Engine_Info_Buffer *info; info = calloc(1, sizeof(Evas_Engine_Info_Buffer)); @@ -136,7 +136,7 @@ eng_info(Evas *e __UNUSED__) } static void -eng_info_free(Evas *e __UNUSED__, void *info) +eng_info_free(Evas *eo_e __UNUSED__, void *info) { Evas_Engine_Info_Buffer *in; in = (Evas_Engine_Info_Buffer *)info; @@ -144,8 +144,9 @@ eng_info_free(Evas *e __UNUSED__, void *info) } static int -eng_setup(Evas *e, void *in) +eng_setup(Evas *eo_e, void *in) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Render_Engine *re; Evas_Engine_Info_Buffer *info; diff --git a/legacy/evas/src/modules/engines/fb/evas_engine.c b/legacy/evas/src/modules/engines/fb/evas_engine.c index e15c02b811..6e63e6fe6a 100644 --- a/legacy/evas/src/modules/engines/fb/evas_engine.c +++ b/legacy/evas/src/modules/engines/fb/evas_engine.c @@ -23,9 +23,9 @@ struct _Render_Engine /* prototypes we will use here */ static void *_output_setup(int w, int h, int rot, int vt, int dev, int refresh); -static void *eng_info(Evas *e); -static void eng_info_free(Evas *e, void *info); -static int eng_setup(Evas *e, void *info); +static void *eng_info(Evas *eo_e); +static void eng_info_free(Evas *eo_e, void *info); +static int eng_setup(Evas *eo_e, void *info); static void eng_output_free(void *data); static void eng_output_resize(void *data, int w, int h); static void eng_output_tile_size_set(void *data, int w, int h); @@ -74,7 +74,7 @@ _output_setup(int w, int h, int rot, int vt, int dev, int refresh) /* engine api this module provides */ static void * -eng_info(Evas *e __UNUSED__) +eng_info(Evas *eo_e __UNUSED__) { Evas_Engine_Info_FB *info; info = calloc(1, sizeof(Evas_Engine_Info_FB)); @@ -85,7 +85,7 @@ eng_info(Evas *e __UNUSED__) } static void -eng_info_free(Evas *e __UNUSED__, void *info) +eng_info_free(Evas *eo_e __UNUSED__, void *info) { Evas_Engine_Info_FB *in; in = (Evas_Engine_Info_FB *)info; @@ -93,8 +93,9 @@ eng_info_free(Evas *e __UNUSED__, void *info) } static int -eng_setup(Evas *e, void *in) +eng_setup(Evas *eo_e, void *in) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Render_Engine *re; Evas_Engine_Info_FB *info; diff --git a/legacy/evas/src/modules/engines/gl_common/evas_gl_api.c b/legacy/evas/src/modules/engines/gl_common/evas_gl_api.c index f40d214e55..99e0508b3f 100644 --- a/legacy/evas/src/modules/engines/gl_common/evas_gl_api.c +++ b/legacy/evas/src/modules/engines/gl_common/evas_gl_api.c @@ -158,13 +158,14 @@ compute_gl_coordinates(Evas_Object *obj, int rot, int clip, int x, int y, int width, int height, int imgc[4], int objc[4]) { + Evas_Object_Protected_Data *pd = eo_data_get(obj, EVAS_OBJ_CLASS); if (rot == 0) { // oringinal image object coordinate in gl coordinate - imgc[0] = obj->cur.geometry.x; - imgc[1] = obj->layer->evas->output.h - obj->cur.geometry.y - obj->cur.geometry.h; - imgc[2] = imgc[0] + obj->cur.geometry.w; - imgc[3] = imgc[1] + obj->cur.geometry.h; + imgc[0] = pd->cur.geometry.x; + imgc[1] = pd->layer->evas->output.h - pd->cur.geometry.y - pd->cur.geometry.h; + imgc[2] = imgc[0] + pd->cur.geometry.w; + imgc[3] = imgc[1] + pd->cur.geometry.h; // transformed (x,y,width,height) in gl coordinate objc[0] = imgc[0] + x; @@ -175,14 +176,14 @@ compute_gl_coordinates(Evas_Object *obj, int rot, int clip, else if (rot == 180) { // oringinal image object coordinate in gl coordinate - imgc[0] = obj->layer->evas->output.w - obj->cur.geometry.x - obj->cur.geometry.w; - imgc[1] = obj->cur.geometry.y; - imgc[2] = imgc[0] + obj->cur.geometry.w; - imgc[3] = imgc[1] + obj->cur.geometry.h; + imgc[0] = pd->layer->evas->output.w - pd->cur.geometry.x - pd->cur.geometry.w; + imgc[1] = pd->cur.geometry.y; + imgc[2] = imgc[0] + pd->cur.geometry.w; + imgc[3] = imgc[1] + pd->cur.geometry.h; // transformed (x,y,width,height) in gl coordinate - objc[0] = imgc[0] + obj->cur.geometry.w - x - width; - objc[1] = imgc[1] + obj->cur.geometry.h - y - height; + objc[0] = imgc[0] + pd->cur.geometry.w - x - width; + objc[1] = imgc[1] + pd->cur.geometry.h - y - height; objc[2] = objc[0] + width; objc[3] = objc[1] + height; @@ -190,13 +191,13 @@ compute_gl_coordinates(Evas_Object *obj, int rot, int clip, else if (rot == 90) { // oringinal image object coordinate in gl coordinate - imgc[0] = obj->cur.geometry.y; - imgc[1] = obj->cur.geometry.x; - imgc[2] = imgc[0] + obj->cur.geometry.h; - imgc[3] = imgc[1] + obj->cur.geometry.w; + imgc[0] = pd->cur.geometry.y; + imgc[1] = pd->cur.geometry.x; + imgc[2] = imgc[0] + pd->cur.geometry.h; + imgc[3] = imgc[1] + pd->cur.geometry.w; // transformed (x,y,width,height) in gl coordinate - objc[0] = imgc[0] + obj->cur.geometry.h - y - height; + objc[0] = imgc[0] + pd->cur.geometry.h - y - height; objc[1] = imgc[1] + x; objc[2] = objc[0] + height; objc[3] = objc[1] + width; @@ -204,14 +205,14 @@ compute_gl_coordinates(Evas_Object *obj, int rot, int clip, else if (rot == 270) { // oringinal image object coordinate in gl coordinate - imgc[0] = obj->layer->evas->output.h - obj->cur.geometry.y - obj->cur.geometry.h; - imgc[1] = obj->layer->evas->output.w - obj->cur.geometry.x - obj->cur.geometry.w; - imgc[2] = imgc[0] + obj->cur.geometry.h; - imgc[3] = imgc[1] + obj->cur.geometry.w; + imgc[0] = pd->layer->evas->output.h - pd->cur.geometry.y - pd->cur.geometry.h; + imgc[1] = pd->layer->evas->output.w - pd->cur.geometry.x - pd->cur.geometry.w; + imgc[2] = imgc[0] + pd->cur.geometry.h; + imgc[3] = imgc[1] + pd->cur.geometry.w; // transformed (x,y,width,height) in gl coordinate objc[0] = imgc[0] + y; - objc[1] = imgc[1] + obj->cur.geometry.w - x - width; + objc[1] = imgc[1] + pd->cur.geometry.w - x - width; objc[2] = objc[0] + height; objc[3] = objc[1] + width; } diff --git a/legacy/evas/src/modules/engines/gl_x11/evas_engine.c b/legacy/evas/src/modules/engines/gl_x11/evas_engine.c index cef291a5fb..91267964c6 100644 --- a/legacy/evas/src/modules/engines/gl_x11/evas_engine.c +++ b/legacy/evas/src/modules/engines/gl_x11/evas_engine.c @@ -592,7 +592,7 @@ int _evas_engine_GL_X11_log_dom = -1; static Evas_Func func, pfunc; static void * -eng_info(Evas *e) +eng_info(Evas *eo_e) { Evas_Engine_Info_GL_X11 *info; @@ -603,11 +603,11 @@ eng_info(Evas *e) info->func.best_depth_get = eng_best_depth_get; info->render_mode = EVAS_RENDER_MODE_BLOCKING; return info; - e = NULL; + eo_e = NULL; } static void -eng_info_free(Evas *e __UNUSED__, void *info) +eng_info_free(Evas *eo_e __UNUSED__, void *info) { Evas_Engine_Info_GL_X11 *in; // dont free! why bother? its not worth it @@ -637,8 +637,9 @@ _re_winfree(Render_Engine *re) } static int -eng_setup(Evas *e, void *in) +eng_setup(Evas *eo_e, void *in) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Render_Engine *re; Evas_Engine_Info_GL_X11 *info; const char *s; @@ -1271,6 +1272,7 @@ eng_output_idle_flush(void *data) Render_Engine *re; re = (Render_Engine *)data; + (void) re; } static void @@ -1335,6 +1337,7 @@ eng_polygon_point_add(void *data, void *context __UNUSED__, void *polygon, int x Render_Engine *re; re = (Render_Engine *)data; + (void) re; return evas_gl_common_poly_point_add(polygon, x, y); } @@ -1344,6 +1347,7 @@ eng_polygon_points_clear(void *data, void *context __UNUSED__, void *polygon) Render_Engine *re; re = (Render_Engine *)data; + (void) re; return evas_gl_common_poly_points_clear(polygon); } @@ -1483,6 +1487,7 @@ eng_image_format_get(void *data __UNUSED__, void *image) // re = (Render_Engine *)data; im = image; + (void) im; return NULL; } diff --git a/legacy/evas/src/modules/engines/software_x11/evas_engine.c b/legacy/evas/src/modules/engines/software_x11/evas_engine.c index f3d7b241b4..cf3dcdd36d 100644 --- a/legacy/evas/src/modules/engines/software_x11/evas_engine.c +++ b/legacy/evas/src/modules/engines/software_x11/evas_engine.c @@ -54,9 +54,9 @@ static void *_best_visual_get(int backend, void *connection, int screen); static unsigned int _best_colormap_get(int backend, void *connection, int screen); static int _best_depth_get(int backend, void *connection, int screen); -static void *eng_info(Evas *e); -static void eng_info_free(Evas *e, void *info); -static int eng_setup(Evas *e, void *info); +static void *eng_info(Evas *eo_e); +static void eng_info_free(Evas *eo_e, void *info); +static int eng_setup(Evas *eo_e, void *info); static void eng_output_free(void *data); static void eng_output_resize(void *data, int w, int h); static void eng_output_tile_size_set(void *data, int w, int h); @@ -355,7 +355,7 @@ _best_depth_get(int backend, void *connection, int screen) /* engine api this module provides */ static void * -eng_info(Evas *e __UNUSED__) +eng_info(Evas *eo_e __UNUSED__) { Evas_Engine_Info_Software_X11 *info; @@ -374,7 +374,7 @@ eng_info(Evas *e __UNUSED__) } static void -eng_info_free(Evas *e __UNUSED__, void *info) +eng_info_free(Evas *eo_e __UNUSED__, void *info) { Evas_Engine_Info_Software_X11 *in; @@ -383,8 +383,9 @@ eng_info_free(Evas *e __UNUSED__, void *info) } static int -eng_setup(Evas *e, void *in) +eng_setup(Evas *eo_e, void *in) { + Evas_Public_Data *e = eo_data_get(eo_e, EVAS_CLASS); Evas_Engine_Info_Software_X11 *info; Render_Engine *re = NULL; diff --git a/legacy/evas/src/modules/engines/wayland_shm/evas_engine.c b/legacy/evas/src/modules/engines/wayland_shm/evas_engine.c index 4c7d943d08..ed4e6b5374 100644 --- a/legacy/evas/src/modules/engines/wayland_shm/evas_engine.c +++ b/legacy/evas/src/modules/engines/wayland_shm/evas_engine.c @@ -31,9 +31,9 @@ int _evas_engine_way_shm_log_dom = -1; static void *_output_setup(int w, int h, int rotation, Eina_Bool alpha, void *dest); /* engine function prototypes */ -static void *eng_info(Evas *evas __UNUSED__); -static void eng_info_free(Evas *evas __UNUSED__, void *info); -static int eng_setup(Evas *evas, void *info); +static void *eng_info(Evas *eo_evas __UNUSED__); +static void eng_info_free(Evas *eo_evas __UNUSED__, void *info); +static int eng_setup(Evas *eo_evas, void *info); static void eng_output_free(void *data); static void eng_output_resize(void *data, int w, int h); static void eng_output_tile_size_set(void *data, int w, int h); @@ -75,7 +75,7 @@ _output_setup(int w, int h, int rotation, Eina_Bool alpha, void *dest) /* engine functions */ static void * -eng_info(Evas *evas __UNUSED__) +eng_info(Evas *eo_evas __UNUSED__) { Evas_Engine_Info_Wayland_Shm *info; @@ -91,7 +91,7 @@ eng_info(Evas *evas __UNUSED__) } static void -eng_info_free(Evas *evas __UNUSED__, void *info) +eng_info_free(Evas *eo_evas __UNUSED__, void *info) { Evas_Engine_Info_Wayland_Shm *in; @@ -102,8 +102,9 @@ eng_info_free(Evas *evas __UNUSED__, void *info) } static int -eng_setup(Evas *evas, void *info) +eng_setup(Evas *eo_evas, void *info) { + Evas_Public_Data *evas = eo_data_get(eo_evas, EVAS_CLASS); Evas_Engine_Info_Wayland_Shm *in; Render_Engine *re = NULL;