* @param data The data pointer to be passed to @p func
*
* This function adds a function callback to an object when the event of type
- * @p type occurs on object @p obj. The fucntion is @p func.
+ * @p type occurs on object @p obj. The function is @p func.
*
* In the event of a memory allocation error during addition of the callback to
* the object, evas_alloc_error() should be used to determine the nature of
* data structure that may or may not be passed to the callback, depending on
* the event type that triggered the callback.
*
- * The event type @p type to trigger the function mys be one of
+ * The event type @p type to trigger the function may be one of
* EVAS_CALLBACK_MOUSE_IN, EVAS_CALLBACK_MOUSE_OUT, EVAS_CALLBACK_MOUSE_DOWN,
* EVAS_CALLBACK_MOUSE_UP, EVAS_CALLBACK_MOUSE_MOVE, EVAS_CALLBACK_MOUSE_WHEEL,
* EVAS_CALLBACK_FREE, EVAS_CALLBACK_KEY_DOWN, EVAS_CALLBACK_KEY_UP,
* EVAS_CALLBACK_HIDE, EVAS_CALLBACK_MOVE, EVAS_CALLBACK_RESIZE or EVAS_CALLBACK_RESTACK.
* This determines the kind of event that will trigger the callback to be called.
* The @p event_info pointer passed to the callback will be one of the
- * following, depending on the event tiggering it:
+ * following, depending on the event triggering it:
*
* EVAS_CALLBACK_MOUSE_IN: event_info = pointer to Evas_Event_Mouse_In
*
* or by the object being shown, raised, moved, resized, or other objects
* being moved out of the way, hidden, lowered or moved out of the way.
*
- * In the event structure whose pointer is passed to the callback, the
- * following members indicate the following:
- *
* EVAS_CALLBACK_MOUSE_OUT: event_info = pointer to Evas_Event_Mouse_Out
*
* This event is triggered exactly like EVAS_CALLBACK_MOUSE_IN is, but occurs
* when the mouse pointer exits an object. Note that no out events will be
* reported if the mouse pointer is implicitly grabbed to an object (the
* mouse buttons are down at all and any were pressed on that object). An
- * out event will be reported as soon as the mouse is no longer grabbed
- * (no mouse buttons are depressed). Out events will be reported if the mouse
- * has left the object once all buttons are released.
+ * out event will be reported as soon as the mouse is no longer grabbed (no
+ * mouse buttons are depressed). Out events will be reported once all buttons
+ * are released, if the mouse has left the object.
*
* EVAS_CALLBACK_MOUSE_DOWN: event_info = pointer to Evas_Event_Mouse_Down
*
* This event is triggered by a mouse button being depressed while over an
- * object. This will passively lock all events to that object until all mouse
- * buttons have been released. That means if this mouse button is the first
- * to be pressed, all future button presses will be reported to this object
- * only until no buttons are down. That includes mouse move events, in and out
- * events. On all buttons being release, event propagation processed as normal.
+ * object. This causes this object to passively grab the mouse until all mouse
+ * buttons have been released. That means if this mouse button is the first to
+ * be pressed, all future mouse events will be reported to only this object
+ * until no buttons are down. That includes mouse move events, in and out
+ * events, and further button presses. When all buttons are released, event
+ * propagation occurs as normal.
*
* EVAS_CALLBACK_MOUSE_UP: event_info = pointer to Evas_Event_Mouse_Up
*
- * This event is driggered by a mouse button being released while over an
+ * This event is triggered by a mouse button being released while over an
* object or when passively grabbed to an object. If this is the last mouse
* button to be raised on an object then the passive grab is released and
* event processing will continue as normal.
*
* This event is triggered just before Evas is about to free all memory used
* by an object and remove all references to it. This is useful for programs
- * to sue if they attached data to an object and want to free it when the
+ * to use if they attached data to an object and want to free it when the
* object is deleted. The object is still valid when this callback is called,
* but after this callback returns, there is no guarantee on the object's
* validity.
*
* EVAS_CALLBACK_SHOW: event_info = NULL
*
- * This event is triggered being shown by evas_object_show().
+ * This event is triggered by the object being shown by evas_object_show().
*
* EVAS_CALLBACK_HIDE: event_info = NULL
*
* EVAS_CALLBACK_MOVE: event_info = NULL
*
* This event is triggered by an object being moved. evas_object_move() can
- * trigger this, as can any object specific manipulations that would mean the
- * objects origin could move.
+ * trigger this, as can any object-specific manipulations that would mean the
+ * object's origin could move.
*
* EVAS_CALLBACK_RESIZE: event_info = NULL
*
* This event is triggered by an object being resized. Resizes can be
- * triggered by evas_object_resize() or by any object specific calls that may
+ * triggered by evas_object_resize() or by any object-specific calls that may
* cause the object to resize.
*
* Example:
* @param obj Object to remove a callback from
* @param type The type of event that was triggering the callback
* @param func The function that was to be called when the event was triggered
- * @return The data pointer that was to be passwd to the callback
+ * @return The data pointer that was to be passed to the callback
*
* This function removes the most recently added callback from the object
* @p obj which was triggered by the event type @p type and was calling the
- * function @p func when triggered. If the callback is successful it will also
- * return the data pointer, passed to evas_object_event_callback_add() when
- * the callback was added to the object. If not successful NULL will be
+ * function @p func when triggered. If the removal is successful it will also
+ * return the data pointer that was passed to evas_object_event_callback_add()
+ * when the callback was added to the object. If not successful NULL will be
* returned.
*
* Example:
* RESULT = (OBJ * CLIP) / (255 * 255) per color element (red, green, blue and
* alpha). Clipping is recursive, so clip objects may be clipped by other
* objects, and their color will in tern be multiplied. You may NOT set up
- * circular clipping lists (i.e. object 1 clips object 2 which clips object 2).
+ * circular clipping lists (i.e. object 1 clips object 2 which clips object 1).
* The behavior of Evas is undefined in this case. Objects which do not clip
* others are visible as normal, those that clip 1 or more objects become
* invisible themselves, only affecting what they clip. If an object ceases to
* have other objects being clipped by it, it will become visible again. The
* visibility of an object affects the objects that are clipped by it, so if
- * the object clipping others is now shown, the objects clipped will not be
+ * the object clipping others is not shown, the objects clipped will not be
* shown either. If the object was being clipped by another object when this
* function is called, it is implicitly removed from the clipper it is being
* clipped to, and now is made to clip its new clipper.
*
* At the moment the only objects that can validly be used to clip other
- * objects are rectangle objects. All other objects types are invalid and the
- * results of using them is undefined.
+ * objects are rectangle objects. All other object types are invalid and the
+ * result of using them is undefined.
*
* The clip object @p clip must be a valid object, but may also be NULL in
* which case the effect of this function is the same as calling
* Evas_Object *clipper;
*
* clipper = evas_object_rectangle_add(evas);
- * evas_object_color_ser(clipper, 255, 255, 255, 255);
+ * evas_object_color_set(clipper, 255, 255, 255, 255);
* evas_object_move(clipper, 10, 10);
* evas_object_resize(clipper, 20, 50);
* evas_object_clip_set(obj, clipper);
* Get the object clipping this one (if any).
* @param obj The object to get the clipper from
*
- * This function returns the the object clipping @p obj. If it is not being
+ * This function returns the the object clipping @p obj. If @p obj not being
* clipped, NULL is returned. The object @p obj must be a valid object.
*
- * See also evas_object_clip_set(), evas_object_clipees_get() and
+ * See also evas_object_clip_set(), evas_object_clip_unset() and
* evas_object_clipees_get().
*
* Example:
*
* This returns the inernal list handle that contains all objects clipped by
* the object @p obj. If none are clipped, it returns NULL. This list is only
- * valid and should be fetched again with another call to
- * evas_object_clipees_get() if any objects being clipped by this object are
- * unclipped, clipped by a new object, are deleted or the clipper is deleted.
- * These operations will invalidate the list returned and so it should not be
- * used anymore after that point. Any use of the list after this may have
+ * valid until the clip list is changed and should be fetched again with another
+ * call to evas_object_clipees_get() if any objects being clipped by this object
+ * are unclipped, clipped by a new object, are deleted or the clipper is
+ * deleted. These operations will invalidate the list returned so it should
+ * not be used anymore after that point. Any use of the list after this may have
* undefined results, not limited just to strange behavior but possible
- * segfaults and other strange memory errors. The object @p obj must be a
- * valid object.
+ * segfaults and other strange memory errors. The object @p obj must be a valid
+ * object.
*
* See also evas_object_clip_set(), evas_object_clip_unset() and
* evas_object_clip_get().
}
}
if (copy) copy = evas_list_free(copy);
- /* go thru out current list of ins */
+ /* go thru our current list of ins */
for (l = ins; l; l = l->next)
{
Evas_Object *obj;
}
}
/* free our old list of ins */
- e->pointer.object.in = evas_list_free(e->pointer.object.in);
+ evas_list_free(e->pointer.object.in);
/* and set up the new one */
e->pointer.object.in = ins;
}
*
* This function creates a new Evas Canvas object that is completely
* uninitialised. You cannot sensibly use this until it has been initialised.
- * You need to set up the rendering engine first for the canvas before you can
- * add any objects to the canvas or render it.
+ * You need to set up the rendering engine for the canvas before you can add any
+ * objects to the canvas or render it.
*
* This function will always succeed and return a valid canvas pointer unless
* the memory allocation fails, in which case NULL will be returned.
* Free an Evas.
* @param e The Pointer to the Evas to be freed
*
- * When called this function frees the Evas Canvas @p e and All Evas Objects
- * created on this canvas. As the objects are freed if they have free callbacks
- * set, they will be called during the execution of this function.
- *
+ * When called this function frees the Evas Canvas @p e and all Evas Objects
+ * created on this canvas. As the objects are freed any that have 'free'
+ * callbacks will have them called during the execution of this function.
* Example:
* @code
* extern Evas *evas;
* @param e The pointer to the Evas Canvas have its engine set
* @param render_method The numeric engine value to use.
*
- * This call sets up which engine an Evas Canvas is to use from then on. This
- * can only be done once and following calls of this function once called once
- * will do nothing. The render method numeric value can be obtained using the
+ * This call sets up which engine an Evas Canvas is to use. This can only be
+ * done once and following calls of this function will do nothing. The @p
+ * render_method numeric value can be obtained using the
* evas_render_method_lookup() call.
*
* Example:
/* if our engine to set it to is invalid - abort */
if (render_method == RENDER_METHOD_INVALID) return;
- /* if the engine is alreayd set up - abort */
+ /* if the engine is already set up - abort */
if (e->output.render_method != RENDER_METHOD_INVALID) return;
/* set the render method */
e->output.render_method = render_method;
* @param e The pointer to the Evas Canvas
* @return A numeric engine value
*
- * This function returns the rendering engine currently used bu the given Evas
- * Canvas passed in. On success the rendering engine used by the Canvas is
- * returned. On failue 0 is returned.
+ * This function returns the rendering engine currently used by the given Evas
+ * Canvas. On success the numeric value of the rendering engine used
+ * by the Canvas is returned. On failure 0 is returned.
*
* Example:
* @code
* @param e The pointer to the Evas Canvas
* @return A pointer to the Engine Info structure
*
- * Calling this function returns a pointer to a publicly modifyable structure
- * that the rendering engine for the given canvas has set up. Callin this
+ * Calling this function returns a pointer to a publicly modifiable structure
+ * that the rendering engine for the given canvas has set up. Calling this
* function before the rendering engine has been set will result in NULL being
- * returned, as will calling this function on an invalid canvas. The caller
- * does no need to free this structure and shoudl only assume that the pointer
- * tois is valid until evas_engine_info_set() is called or until evas_render()
- * is called. After these calls the contents of this structure and the pointer
- * to it are not guaranteed to be valid.
+ * returned, as will calling this function on an invalid canvas. The caller does
+ * not need to free this structure and should only assume that the pointer is
+ * valid until evas_engine_info_set() is called or until evas_render() is
+ * called. After these calls the contents of this structure and the pointer to
+ * it are not guaranteed to be valid.
*
- * With some engines calling this call and modifying structure parameters,
- * then calling evas_engine_info_set() is used to modify engine parameters
- * whilst the canvas is alive.
+ * With some engines, calling this function and modifying structure parameters
+ * before calling evas_engine_info_set() is the method to modify engine
+ * parameters whilst the canvas is alive.
*
* Example:
* @code
* structure pointer provided by evas_engine_info_get() and not anything else.
*
* You need to set up the Engine Info at least once before doing any rendering
- * or creating any objects on the Evas Canvas. Some engines support the
- * changing of engine parameters during runtime and so the application
- * should call evas_engine_info_get(), modify parameters that need to be
- * modified, and then call evas_engine_info_set() again to have those changes
- * take effect.
+ * or creating any objects on the Evas Canvas. Some engines support the changing
+ * of engine parameters during runtime and so the application should call
+ * evas_engine_info_get(), modify parameters that need to be modified, and then
+ * call this function to have those changes take effect.
*
* Once evas_engine_info_set() is called the Engine Info structure pointer
* should be considered invalid and should not be used again. Use
- * evas_engine_info_get(0 to fetch it again if needed.
+ * evas_engine_info_get() to fetch it again if needed.
*
* Example:
* @code
* @param w The width in output units
* @param h The height in output units
*
- * This function sets the output display size for the Evas Canvas indicated to
- * be the size (for most engines in pixels). The Canvas will render to a
- * rectangle of this size on the output target once this call is called. This
- * is independant of the viewport (view into the canvas world) and will simply
+ * This function sets the output display size for the Evas Canvas indicated (for
+ * most engines these values are in pixels). The Canvas will render to a
+ * rectangle of this size on the output target once this call is called. This is
+ * independent of the viewport (view into the canvas world) and will simply
* stretch the viewport to fill the rectangle indicated by this call.
*
* Example:
*
* This function sets the viewport (in canvas co-ordinate space) that will
* be visible in the canvas ouput. The width and height of the viewport must
- * both be greater than 0. The rectangle described by the co-ordinates is the
- * rectangular region of the canvas co-ordinate space that is visibly mapped
- * and stretched to fill the output target of the canvas when rendering is
- * performed.
+ * both be strictly greater than 0. The rectangle described by the co-ordinates
+ * is the rectangular region of the canvas co-ordinate space that is visibly
+ * mapped and stretched to fill the output target of the canvas when rendering
+ * is performed.
*
- * Co-ordinates do not have to map 1 to 1, but it is generally advised for
- * ease of use that canvas co-ordinates to match output target units for
- * better control, but this is not required.
+ * Co-ordinates do not have to map 1-to-1, but it is generally advised for ease
+ * of use that canvas co-ordinates match output target units (e.g. pixels).
*
* Example:
* @code
*
* Calling this function writes the current canvas output viewport size and
* location values into the variables pointed to by @p x, @p y, @p w and @p h.
- * On success the variables have the output location and size values written
- * to them in canvas units. If either @p x, @p y, @p w or @p h are NULL, it
- * they will not be written to. If @p e is invalid, the results are
- * undefined.
+ * On success the variables have the output location and size values written to
+ * them in canvas units. Any of @p x, @p y, @p w or @p h that are NULL will not
+ * be written to. If @p e is invalid, the results are undefined.
*
* Example:
* @code
* This function looks up a numeric return value for the named engine in the
* string @p name. This is a normal C string, NUL byte terminated. The name
* is case sensitive. If the rendering engine is available, a numeric ID for
- * that engine is returned that is no 0, if the engine is not available, 0
+ * that engine is returned that is not 0. If the engine is not available, 0
* is returned, indicating an invalid engine.
*
- * The programmer should NEVER rely on the numeric ID an engine unless it is
+ * The programmer should NEVER rely on the numeric ID of an engine unless it is
* returned by this function. Programs should NOT be written accessing render
* method ID's directly, without first obtaining it from this function.
*
/**
* List all the rendering engines compiled into the copy of the Evas library
*
- * @return A linked lst whose data members are C strings of engine names
+ * @return A linked list whose data members are C strings of engine names
*
- * Calling this will return the program a handle (pointer) to an Evas linked
- * list. Each node in the linked lists will have the data pointer be a char *
- * pointer to the string name of the rendering engine available. The strings
- * should never be modified, neither should the list be modified. This list
- * should be cleaned up as soon as the program no longer needs it using
+ * Calling this will return a handle (pointer) to an Evas linked list. Each node
+ * in the linked list will have the data pointer be a (char *) pointer to the
+ * string name of the rendering engine available. The strings should never be
+ * modified, neither should the list be modified. This list should be cleaned up
+ * as soon as the program no longer needs it using
* evas_render_method_list_free(). If no engines are available from Evas, NULL
* will be returned.
*
* @param e The pointer to the Evas Canvas
* @return A bitmask of the currently depressed buttons on the cavas
*
- * Calling this function will retunr a 32-bit integer with the appropriate bits
+ * Calling this function will return a 32-bit integer with the appropriate bits
* set to 1 that correspond to a mouse button being depressed. This limits
* Evas to a mouse devices with a maximum of 32 buttons, but that is generally
- * in excess of any host systems pointing device abilities.
+ * in excess of any host system's pointing device abilities.
*
* A canvas by default begins with no mouse buttons being pressed and only
* calls to evas_event_feed_mouse_down(), evas_event_feed_mouse_down_data(),
}
/**
- * Returns if the mouse pointer is logically inside the canvas
+ * Returns whether the mouse pointer is logically inside the canvas
*
* @param e The pointer to the Evas Canvas
- * @return An integer (0 or 1) corresponding to the outside/inside pointer
+ * @return An integer that is 1 if the mouse is inside the canvas, 0 otherwise
*
* When this function is called it will return a value of either 0 or 1,
* depending on if evas_event_feed_mouse_in(), evas_event_feed_mouse_in_data(),
* extern Evas *evas;
*
* if (evas_pointer_inside_get(evas)) printf("Mouse is in!\n");
- * else printf("Mouse is out\n");
+ * else printf("Mouse is out!\n");
* @endcode
*/
Evas_Bool
MAGIC_CHECK_END();
if ((o->cur.file) && (file) && (!strcmp(o->cur.file, file)))
{
- if ((o->cur.key) && (key) && (!strcmp(o->cur.key, key)))
- return;
if ((!o->cur.key) && (!key))
return;
+ if ((o->cur.key) && (key) && (!strcmp(o->cur.key, key)))
+ return;
}
if (o->cur.file) free(o->cur.file);
if (o->cur.key) free(o->cur.key);
obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output,
o->engine_data);
o->load_error = EVAS_LOAD_ERROR_NONE;
- o->cur.has_alpha = 1;
- o->cur.image.w = 0;
- o->cur.image.h = 0;
o->engine_data = obj->layer->evas->engine.func->image_load(obj->layer->evas->engine.data.output,
o->cur.file,
o->cur.key,
else
{
o->load_error = EVAS_LOAD_ERROR_GENERIC;
+ o->cur.has_alpha = 1;
+ o->cur.image.w = 0;
+ o->cur.image.h = 0;
}
o->changed = 1;
evas_object_change(obj);
/* rendering. this could mean loading the image data, retrieving it from */
/* 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 */
+ /* if so what and where and add the appropriate redraw rectangles */
o = (Evas_Object_Image *)(obj->object_data);
/* if someone is clipping this obj - go calculate the clipper */
if (obj->cur.clipper)
updates = evas_object_render_pre_visible_change(updates, obj, is_v, was_v);
goto done;
}
- /* its not visible - we accounted for it appearing or not so just abort */
+ /* 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 */
updates = evas_object_render_pre_clipper_change(updates, obj);
- /* if we restacked (layer or just within a layer) and dont clip anyone */
+ /* if we restacked (layer or just within a layer) and don't clip anyone */
if (obj->restack)
{
updates = evas_object_render_pre_prev_cur_add(updates, 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 */
- /* arent fully opaque and we are visible */
+ /* aren't fully opaque and we are visible */
if (evas_object_is_visible(obj) &&
evas_object_is_opaque(obj))
obj->layer->evas->engine.func->output_redraws_rect_del(obj->layer->evas->engine.data.output,
Evas_Object_Image *o;
/* this returns 1 if the internal object data implies that the object is */
- /* currently fulyl opque over the entire rectangle it occupies */
+ /* currently fully opaque over the entire rectangle it occupies */
o = (Evas_Object_Image *)(obj->object_data);
if (!o->engine_data) return 0;
if (o->cur.has_alpha) return 0;
Evas_Object_Image *o;
/* this returns 1 if the internal object data implies that the object was */
- /* currently fulyl opque over the entire rectangle it occupies */
+ /* previously fully opaque over the entire rectangle it occupies */
o = (Evas_Object_Image *)(obj->object_data);
if (!o->engine_data) return 0;
if (o->prev.has_alpha) return 0;
/* rendering. this could mean loading the image data, retrieving it from */
/* 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 lines */
+ /* 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)
updates = evas_object_render_pre_visible_change(updates, obj, is_v, was_v);
goto done;
}
- /* its not visible - we accounted for it appearing or not so just abort */
+ /* 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 */
updates = evas_object_render_pre_clipper_change(updates, obj);
Evas_Object_Line *o;
/* this returns 1 if the internal object data implies that the object is */
- /* currently fulyl opque over the entire line it occupies */
+ /* currently fully opaque over the entire line it occupies */
o = (Evas_Object_Line *)(obj->object_data);
return 0;
}
Evas_Object_Line *o;
/* this returns 1 if the internal object data implies that the object was */
- /* currently fulyl opque over the entire line it occupies */
+ /* previously fully opaque over the entire line it occupies */
o = (Evas_Object_Line *)(obj->object_data);
return 0;
}
Evas_Object_Line *o;
/* 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 */
+ /* on object private data. not much use for rects, but for polys, images */
/* and other complex objects it might be */
o = (Evas_Object_Line *)(obj->object_data);
return 1;
Evas_Object_Line *o;
/* 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 */
+ /* on object private data. not much use for rects, but for polys, images */
/* and other complex objects it might be */
o = (Evas_Object_Line *)(obj->object_data);
return 1;
/* rendering. this could mean loading the image data, retrieving it from */
/* 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 lines */
+ /* 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)
updates = evas_object_render_pre_visible_change(updates, obj, is_v, was_v);
goto done;
}
- /* its not visible - we accounted for it appearing or not so just abort */
+ /* 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 */
updates = evas_object_render_pre_clipper_change(updates, obj);
Evas_Object_Polygon *o;
/* this returns 1 if the internal object data implies that the object is */
- /* currently fulyl opque over the entire line it occupies */
+ /* currently fully opaque over the entire line it occupies */
o = (Evas_Object_Polygon *)(obj->object_data);
return 0;
}
Evas_Object_Polygon *o;
/* this returns 1 if the internal object data implies that the object was */
- /* currently fulyl opque over the entire line it occupies */
+ /* previously fully opaque over the entire line it occupies */
o = (Evas_Object_Polygon *)(obj->object_data);
return 0;
}
Evas_Object_Polygon *o;
/* 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 */
+ /* on object private data. not much use for rects, but for polys, images */
/* and other complex objects it might be */
o = (Evas_Object_Polygon *)(obj->object_data);
return 1;
Evas_Object_Polygon *o;
/* 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 */
+ /* on object private data. not much use for rects, but for polys, images */
/* and other complex objects it might be */
o = (Evas_Object_Polygon *)(obj->object_data);
return 1;
/* rendering. this could mean loading the image data, retrieving it from */
/* 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 */
+ /* if so what and where and add the appropriate redraw rectangles */
o = (Evas_Object_Rectangle *)(obj->object_data);
/* if someone is clipping this obj - go calculate the clipper */
if (obj->cur.clipper)
updates = evas_object_render_pre_visible_change(updates, obj, is_v, was_v);
goto done;
}
- /* its not visible - we accounted for it appearing or not so just abort */
+ /* 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 */
updates = evas_object_render_pre_clipper_change(updates, obj);
- /* if we restacked (layer or just within a layer) and dont clip anyone */
+ /* if we restacked (layer or just within a layer) and don't clip anyone */
if ((obj->restack) && (!obj->clip.clipees))
{
updates = evas_object_render_pre_prev_cur_add(updates, obj);
Evas_Object_Rectangle *o;
/* this returns 1 if the internal object data implies that the object is */
- /* currently fulyl opque over the entire rectangle it occupies */
+ /* currently fully opaque over the entire rectangle it occupies */
o = (Evas_Object_Rectangle *)(obj->object_data);
return 1;
}
Evas_Object_Rectangle *o;
/* this returns 1 if the internal object data implies that the object was */
- /* currently fulyl opque over the entire rectangle it occupies */
+ /* previously fully opaque over the entire rectangle it occupies */
o = (Evas_Object_Rectangle *)(obj->object_data);
return 1;
}
Evas_Object_Rectangle *o;
/* 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 */
+ /* on object private data. not much use for rects, but for polys, images */
/* and other complex objects it might be */
o = (Evas_Object_Rectangle *)(obj->object_data);
return 1;
Evas_Object_Rectangle *o;
/* 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 */
+ /* on object private data. not much use for rects, but for polys, images */
/* and other complex objects it might be */
o = (Evas_Object_Rectangle *)(obj->object_data);
return 1;
/* save this list */
obscuring_objects_orig = obscuring_objects;
obscuring_objects = NULL;
- /* phase 6. go thu each update rect and render objects in it*/
+ /* phase 6. go thru each update rect and render objects in it*/
while ((surface =
e->engine.func->output_redraws_next_update_get(e->engine.data.output,
&ux, &uy, &uw, &uh,
Evas_List *l3;
obj = (Evas_Object *)(ll->data);
- /* if its in our outpout rect and it doesnt clip anything */
+ /* if it's in our outpout rect and it doesn't clip anything */
if (evas_object_is_in_output_rect(obj, ux, uy, uw, uh) &&
(!obj->clip.clipees) &&
(obj->cur.visible) &&
projects / platform / upstream / efl.git / commitdiff