esac
AC_MSG_CHECKING(whether to build neon code)
AC_ARG_ENABLE(cpu-neon,
- AC_HELP_STRING([--enable-cpu-neon], [enable neon code - with gcc you will need these CFLAGS for it to begin to work, and even then your gcc may have broken or non-existant support: -mcpu=cortex-a8 -mfloat-abi=softfp -mfpu=neon]),
+ AC_HELP_STRING([--enable-cpu-neon], [enable neon code - with gcc you will need these CFLAGS for it to begin to work, and even then your gcc may have broken or non-existent support: -mcpu=cortex-a8 -mfloat-abi=softfp -mfpu=neon]),
[
if test "x$enableval" = "xyes" ; then
AC_TRY_COMPILE([#include <arm_neon.h>],
Evas is a canvas display library. This is markedly different from most
display and windowing systems as a Canvas is structural and is also a state
-engine, wheras most display and windowing systems are immediate mode display
+engine, whereas most display and windowing systems are immediate mode display
targets. Evas handles the logic between a structural display via its' state
engine, and controls the target windowing system in order to produce
rendered results of the current canvases state on the display.
are displayed on the screen (normally). Once the commands are executed the
display system has little or no idea of how to reproduce this image again,
and so has to be instructed by the application how to redraw sections of the
-screen whenever needed. Each sucessive command will be executed as
+screen whenever needed. Each successive command will be executed as
instructed by the application and either emulated by software or sent to the
graphics hardware on the device to be performed.
c->client_main->data = eina_list_remove(c->client_main->data, img);
else
c->data = eina_list_remove(c->data, img);
- // FIXME: preload doesnt work async
+ // FIXME: preload doesn't work async
img_preload(img);
LKU(img->lock);
}
/* load error identifiers, see evas_load_error_str() */
#define EVAS_LOAD_ERROR_NONE 0 /**< No error on load */
-#define EVAS_LOAD_ERROR_GENERIC 1 /**< A non-specific error occured */
+#define EVAS_LOAD_ERROR_GENERIC 1 /**< A non-specific error occurred */
#define EVAS_LOAD_ERROR_DOES_NOT_EXIST 2 /**< File (or file path) does not exist */
#define EVAS_LOAD_ERROR_PERMISSION_DENIED 3 /**< Permission deinied to an existing file (or path) */
#define EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED 4 /**< Allocation of resources failure prevented load */
* that.
*
* An example of actual use of this API is for image asynchronous
- * preload inside evas. If the canvas was instantiated throught
+ * preload inside evas. If the canvas was instantiated through
* ecore-evas usage, ecore itself will take care of calling those
* events' processing.
*
* The first parameter @p data in this function will be the same value
* passed to evas_object_event_callback_add() as the @p data
* parameter. The second parameter is a convenience for the programmer
- * to know what evas canvas the event occured on. The third parameter
- * @p obj is the Object handle on which the event occured. The foruth
+ * to know what evas canvas the event occurred on. The third parameter
+ * @p obj is the Object handle on which the event occurred. The foruth
* parameter @p event_info is a pointer to a data structure that may
* or may not be passed to the callback, depending on the event type
* that triggered the callback.
* The first parameter @p data in this function will be the same value
* passed to evas_event_callback_add() as the @p data parameter. The
* second parameter @p e is the canvas handle on which the event
- * occured. The third parameter @p event_info is a pointer to a data
+ * occurred. The third parameter @p event_info is a pointer to a data
* structure that may or may not be passed to the callback, depending
* on the event type that triggered the callback.
*
* callbacks, but also to be repeated on the next lower object in the
* stack.
*
- * If @p repeat is false, events occuring on @p obj will be processed
+ * If @p repeat is false, events occurring on @p obj will be processed
* normally.
*/
EAPI void
* This function has no effect if @p obj is not a member of a smart
* object.
*
- * If @p prop is true, events occuring on this object will propagate on
+ * If @p prop is true, events occurring on this object will propagate on
* to the smart object of which @p obj is a member.
*
* If @p prop is false, events for which callbacks are set on the member
/**
* Determine whether an object is set to propagate events.
* @param obj
- * @return propogate events state
+ * @return propagate events state
*/
EAPI Eina_Bool
evas_object_propagate_events_get(const Evas_Object *obj)
/**
* Retrieves the layer of the evas that the given object is part of.
*
- * Be carefull, it doesn't make sense to change the layer of smart object's
+ * Be careful, it doesn't make sense to change the layer of smart object's
* child. So the returned value could be wrong in some case. Don't rely on
* it's accuracy.
*
*
* @param e The pointer to the Evas Canvas
* @param info The pointer to the Engine Info to use
- * @return 1 if no error occured, 0 otherwise
+ * @return 1 if no error occurred, 0 otherwise
* @ingroup Evas_Output_Method
*/
EAPI int
case EVAS_LOAD_ERROR_NONE:
return "No error on load";
case EVAS_LOAD_ERROR_GENERIC:
- return "A non-specific error occured";
+ return "A non-specific error occurred";
case EVAS_LOAD_ERROR_DOES_NOT_EXIST:
return "File (or file path) does not exist";
case EVAS_LOAD_ERROR_PERMISSION_DENIED:
* Pre-multiplies data by an alpha factor.
*
* @param data The data value.
- * @param len The lenght value.
+ * @param len The length value.
*
* This function pre-multiplies a given data by an alpha
* factor. Alpha factor is used to define transparency.
* Undo pre-multiplication data by an alpha factor.
*
* @param data The data value.
- * @param len The lenght value.
+ * @param len The length value.
*
* This function undoes pre-multiplication of a given data by an alpha
* factor. Alpha factor is used to define transparency.
*
* @param m map to change.
* @param degrees amount of degrees from 0.0 to 360.0 to rotate.
- * @param cx rotation's center horizontal positon.
- * @param cy rotation's center vertical positon.
+ * @param cx rotation's center horizontal position.
+ * @param cy rotation's center vertical position.
*
* @see evas_map_point_coord_set()
* @see evas_map_util_zoom()
* @param m map to change.
* @param zoomx horizontal zoom to use.
* @param zoomy vertical zoom to use.
- * @param cx zooming center horizontal positon.
- * @param cy zooming center vertical positon.
+ * @param cx zooming center horizontal position.
+ * @param cy zooming center vertical position.
*
* @see evas_map_point_coord_set()
* @see evas_map_util_rotate()
* @param dx amount of degrees from 0.0 to 360.0 to rotate arount X axis.
* @param dy amount of degrees from 0.0 to 360.0 to rotate arount Y axis.
* @param dz amount of degrees from 0.0 to 360.0 to rotate arount Z axis.
- * @param cx rotation's center horizontal positon.
- * @param cy rotation's center vertical positon.
- * @param cz rotation's center vertical positon.
+ * @param cx rotation's center horizontal position.
+ * @param cy rotation's center vertical position.
+ * @param cz rotation's center vertical position.
*/
EAPI void
evas_map_util_3d_rotate(Evas_Map *m, double dx, double dy, double dz,
* properties apply for padding/positioning relative to the overall
* height of the box. Finally, there is the @c weight_x property,
* which, if set to a non-zero value, tells the container that the
- * child width is not pre-defined. If the container can't accomodate
+ * child width is not pre-defined. If the container can't accommodate
* all its children, it sets the widths of the children *with weights*
* to sizes as small as they can all fit into it. If the size
* required by the children is less than the available, the box
}
}
/* if it changed geometry - and obviously not visibility or color */
- /* caluclate differences since we have a constant color fill */
+ /* calculate differences since we have a constant color fill */
/* we really only need to update the differences */
#if 0 // XXX: maybe buggy?
if (((obj->cur.geometry.x != obj->prev.geometry.x) ||
*
* @param obj The given canvas object pointer.
* @param func The given function to be the callback function.
- * @param data The data passed to the callback fucntion.
+ * @param data The data passed to the callback function.
*
* This function sets a callback function to intercepts a show event
* of a canvas object.
*
* @param obj The given canvas object pointer.
* @param func The given function to be the callback function.
- * @param data The data passed to the callback fucntion.
+ * @param data The data passed to the callback function.
*
* This function sets a callback function to intercepts a hide event
* of a canvas object.
*
* @param obj The given canvas object pointer.
* @param func The given function to be the callback function.
- * @param data The data passed to the callback fucntion.
+ * @param data The data passed to the callback function.
*
* This function sets a callback function to intercepts a move event
* of a canvas object.
goto done;
}
/* if it changed geometry - and obviously not visibility or color */
- /* caluclate differences since we have a constant color fill */
+ /* calculate differences since we have a constant color fill */
/* we really only need to update the differences */
if ((obj->cur.geometry.x != obj->prev.geometry.x) ||
(obj->cur.geometry.y != obj->prev.geometry.y) ||
* @endcode
* This is more evident in images, but text, textblock, lines
* and polygons will behave similarly. Check their specific APIs
- * to know how to achive your desired behavior.
+ * to know how to achieve your desired behavior.
*
* @ingroup Evas_Object_Group_Basic
*/
goto done;
}
/* if it changed geometry - and obviously not visibility or color */
- /* caluclate differences since we have a constant color fill */
+ /* calculate differences since we have a constant color fill */
/* we really only need to update the differences */
if ((obj->cur.geometry.x != obj->prev.geometry.x) ||
(obj->cur.geometry.y != obj->prev.geometry.y) ||
goto done;
}
/* if it changed geometry - and obviously not visibility or color */
- /* caluclate differences since we have a constant color fill */
+ /* calculate differences since we have a constant color fill */
/* we really only need to update the differences */
if ((obj->cur.geometry.x != obj->prev.geometry.x) ||
(obj->cur.geometry.y != obj->prev.geometry.y) ||
* @param event_info an event specific struct of info to pass to the callback
*
* This should be called internally in the smart object when some specific
- * event has occured. The documentation for the smart object should include
+ * event has occurred. The documentation for the smart object should include
* a list of possible events and what type of @p event_info to expect.
*
* @ingroup Evas_Smart_Object_Group
/**
* 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 possibilty of RTL in the text.
+ * because of the possibility of RTL in the text.
* To be documented.
*
* FIXME: To be fixed.
* also have the added benefit of updating automatically upon textblock changes,
* this means that if you have a cursor pointing to a specific character, it'll
* still point to it even after you change the whole object completely (as long
- * as the char was not deleted), this is not possible without updating, beacuse
+ * as the char was not deleted), this is not possible without updating, because
* as mentioned, each cursor holds a character position. There are many
* functions that handle cursors, just check out the evas_textblock_cursor*
* functions. For creation and deletion of cursors check out:
*
* @param obj the evas object - should not be NULL.
* @param fmt The format to populate - should not be NULL.
- * @param[in] cmd the command to proccess, should be stringshared.
+ * @param[in] cmd the command to process, should be stringshared.
* @param[in] param the parameter of the command.
*/
static void
/**
* @internal
- * Handles a format by proccessing a format node. It returns the relevant format
- * through _fmt and updates the padding throught style_pad_*. If needed,
+ * Handles a format by processing a format node. It returns the relevant format
+ * through _fmt and updates the padding through style_pad_*. If needed,
* it creates a format item.
*
* @param obj the evas object - NOT NULL.
/* run through all text and format nodes generating lines */
if (!c->o->text_nodes && !c->o->format_nodes)
{
- /* If there are no nodes and lines, do the inital creation. */
+ /* If there are no nodes and lines, do the initial creation. */
if (!c->par && !c->ln)
{
_layout_paragraph_new(c);
* Return the format at a specific position.
*
* @param cur the cursor to the position.
- * @return the format node at the specific postion or NULL if not found.
+ * @return the format node at the specific position or NULL if not found.
*/
static Evas_Object_Textblock_Node_Format *
_evas_textblock_cursor_node_format_at_pos_get(const Evas_Textblock_Cursor *cur)
* @internal
* Return the last format node at the position of the format node n.
*
- * @param n a format node at the positon.
+ * @param n a format node at the position.
* @return the last format node at the position of n.
*/
static Evas_Object_Textblock_Node_Format *
* Returns the visible format at a specific location.
*
* @param n a format at the specific position.
- * @return the format node at the specific postion or NULL if not found.
+ * @return the format node at the specific position or NULL if not found.
*/
static Evas_Object_Textblock_Node_Format *
_evas_textblock_node_visible_at_pos_get(const Evas_Object_Textblock_Node_Format *n)
* position of the cursor in the text node is returned or the previous's text
* node's format node.
*
- * @param cur teh position to look at.
+ * @param cur the position to look at.
* @return the format node found.
*/
static Evas_Object_Textblock_Node_Format *
* position of the cursor in the text node is returned or the previous's text
* node's format node.
*
- * @param cur teh position to look at.
+ * @param cur the position to look at.
* @return the format node found.
*/
static Evas_Object_Textblock_Node_Format *
goto done;
}
/* if it changed geometry - and obviously not visibility or color */
- /* caluclate differences since we have a constant color fill */
+ /* calculate differences since we have a constant color fill */
/* we really only need to update the differences */
if ((obj->cur.geometry.x != obj->prev.geometry.x) ||
(obj->cur.geometry.y != obj->prev.geometry.y) ||
/* Thanks to Diz for this code. i've munged it a little and turned it into */
/* inline macros. I tried beating it with a different algorithm using MMX */
/* but failed. So here we are. This is the fastest YUV->RGB i know of for */
-/* x86. It has an issue that it doesnt convert colours accurately so the */
+/* x86. It has an issue that it doesn't convert colours accurately so the */
/* image looks a little "yellowy". This is a result of only 10.6 fixed point */
/* resolution as opposed to 16.16 in the C code. This could be fixed by */
/* processing half the number of pixels per cycle and going up to 32bits */
/* 2 */ tmp1 = vec_perm(tmp1, tmp1, uperm);
/* 2 */ tmp2 = vec_perm(tmp2, tmp2, vperm);
- /* Avoid dependancy stalls on yperm and calculate the 4 u values */
+ /* Avoid dependency stalls on yperm and calculate the 4 u values */
/* 3 */ yperm = vec_lvsr(12, yp1);
/* 1 */ tmp1 = (vector signed short)vec_mergeh((vector unsigned char)tmp1,
(vector unsigned char)tmp1);
/* 1 */ y = vec_sub(y, c16);
/* 4 */ y = vec_mladd(ymul, y, (vector signed short)zero);
- /* Perform non-dependant multiplies first. */
+ /* Perform non-dependent multiplies first. */
/* 4 */ tmp1 = vec_mladd(crv, v, y);
/* 4 */ tmp2 = vec_mladd(cgv, v, tmp2);
/* 4 */ tmp3 = vec_mladd(cbu, u, y);
/* 1 */ y = (vector signed short)vec_mergeh(zero,
(vector unsigned char)y);
- /* Avoid dependancy stalls on yperm */
+ /* Avoid dependency stalls on yperm */
/* 2 */ tmp3 = vec_perm(tmp3, tmp3, yperm);
/* 1 */ tmp3 = (vector signed short)vec_mergeh(zero,
(vector unsigned char)tmp3);
/* 1 */ y = vec_sub(y, c16);
/* 4 */ y = vec_mladd(ymul, y, (vector signed short)zero);
- /* Perform non-dependant multiplies first. */
+ /* Perform non-dependent multiplies first. */
/* 4 */ tmp2 = vec_mladd(cgv, v, tmp2);
/* 4 */ tmp1 = vec_mladd(crv, v, y);
/* 4 */ tmp3 = vec_mladd(cbu, u, y);
u = (*up++) - 128;
v = (*vp++) - 128;
- /* do the top 2 pixels of the 2x2 block whcih shared u & v */
+ /* do the top 2 pixels of the 2x2 block which shared u & v */
/* yuv to rgb */
y = YMUL * ((*yp1++) - 16);
r = LUT_CLIP((y + (crv * v)) >> 16);
u = _v2018[u];
v = _v1596[v];
- /* do the top 2 pixels of the 2x2 block whcih shared u & v */
+ /* do the top 2 pixels of the 2x2 block which shared u & v */
/* yuv to rgb */
y = _v1164[*yp1++];
*((DATA32 *) dp1) = 0xff000000 + RGB_JOIN(LUT_CLIP(y + v), LUT_CLIP(y - vmu), LUT_CLIP(y + u));
/*
- * BiDi handling: We recieve the shaped string + other props from intl_props,
+ * BiDi handling: We receive the shaped string + other props from intl_props,
* we need to reorder it so we'll have the visual string (the way we draw)
* and then for kerning we have to switch the order of the kerning query (as the prev
* is on the right, and not on the left).
/* NOTE: ft2 seems to have a bug. and sometimes returns bizarre
* values to kern by - given same font, same size and same
- * prev_index and index. auto/bytecode or none hinting doesnt
+ * prev_index and index. auto/bytecode or none hinting doesn't
* matter */
FTLOCK();
if (FT_Get_Kerning(fi->src->ft.face,
}
/* size of the string (width and height) in pixels
- * BiDi handling: We recieve the shaped string + other props from intl_props,
+ * BiDi handling: We receive the shaped string + other props from intl_props,
* We only care about the size, and the size does not depend on the visual order.
* As long as we follow the logical string and get kerning data like we should,
* we are fine.
}
/* h & v advance
- * BiDi handling: We recieve the shaped string + other props from intl_props,
+ * BiDi handling: We receive the shaped string + other props from intl_props,
* We don't care about the order, as heights will remain the same (we already did
* shaping) and as long as we go through the logical string and match the kerning
* this way, we are safe.
/* x y w h for char at char pos for null it returns the position right after
* the last char with 0 as width and height.
- * BiDi handling: We recieve the shaped string + other props from intl_props,
+ * BiDi handling: We receive the shaped string + other props from intl_props,
* We care about the actual drawing location of the string, this is why we need
* the visual string. We need to know how it's printed. After that we need to calculate
* the reverse kerning in case of rtl parts. "pos" passed to this function is an
}
/* position of the last char in thext text that will fit in xy.
- * BiDi handling: We recieve the shaped string + other props from intl_props,
+ * BiDi handling: We receive the shaped string + other props from intl_props,
* All we care about is char sizes + kerning so we only really need to get the
* shaped string to utf8, and then just go through it like in english, as it's
* just the logical string, nothing special about that.
struct ext_loader_s
{
- const char *extention;
+ const char *extension;
const char *loader;
};
{
for (i = 0, ++dot; i < (sizeof (loaders) / sizeof (struct ext_loader_s)); ++i)
{
- if (!strcasecmp(dot, loaders[i].extention))
+ if (!strcasecmp(dot, loaders[i].extension))
{
loader = loaders[i].loader;
DBG("known loader '%s' handles extension '%s' of file '%s'",
return;
}
}
- /* it ends on or after the end of thsi span */
+ /* it ends on or after the end of this span */
else if (x2 >= sp_start->x2)
{
/* it starts after the start */
}
return num;
#else
- /* FIXME: need to actually impliment motion vectors. for now it just */
+ /* FIXME: need to actually implement motion vectors. for now it just */
/* implements redraws */
int num;
-/* os dependant file code. for unix-y like fs's only for now */
+/* os dependent file code. for unix-y like fs's only for now */
/* if your os doesn't use unix-like fs starting with "/" for the root and */
/* the file path separator isn't "/" then you may need to help out by */
/* adding in a new set of functions here */
static int _evas_debug_abort = 0;
/**
- * Return if any allocation errors have occured during the prior function
+ * Return if any allocation errors have occurred during the prior function
* @return The allocation error flag
*
- * This function will return if any memory allocation errors occured during,
+ * This function will return if any memory allocation errors occurred during,
* and what kind they were. The return value will be one of
* EVAS_ALLOC_ERROR_NONE, EVAS_ALLOC_ERROR_FATAL or EVAS_ALLOC_ERROR_RECOVERED
* with each meaning something different.
*
- * EVAS_ALLOC_ERROR_NONE means that no errors occured at all and the function
+ * EVAS_ALLOC_ERROR_NONE means that no errors occurred at all and the function
* worked as expected.
*
* EVAS_ALLOC_ERROR_FATAL means the function was completely unable to perform
* recover from the prior functions failure (or try free up memory elsewhere
* and try again after more memory is freed).
*
- * EVAS_ALLOC_ERROR_RECOVERED means that an allocation error occured, but was
+ * EVAS_ALLOC_ERROR_RECOVERED means that an allocation error occurred, but was
* recovered from by evas finding memory of its own it has allocated and
* freeing what it sees as not really usefully allocated memory. What is freed
* may vary. Evas may reduce the resolution of images, free cached images or
return _evas_alloc_error;
}
-/* free cached items only in ram for speed reasons. return 0 if cant free */
+/* free cached items only in ram for speed reasons. return 0 if can't free */
int
evas_mem_free(int mem_required __UNUSED__)
{
return 0;
}
-/* start reducing quality of images etc. return 0 if cant free anything */
+/* start reducing quality of images etc. return 0 if can't free anything */
int
evas_mem_degrade(int mem_required __UNUSED__)
{
evas_cache_image_load_data(&evas_image->cache_entry);
}
- // If the image object wasnt initialized yet
+ // If the image object wasn't initialized yet
if (evas_image != NULL && evas_image->image.data != NULL && !image_ref->IsValid())
{
D3DImageCache::CacheEntryInfo info;
/* be used. If refresh is 0 it uses the DEFAULT mode (the one with no */
/* refresh rate at the end of its name (WIDTHxHEIGHT-REFRESH) */
/* NB: in 8bpp you get a 332 palette. This is fixed so all modes are */
-/* "truecolor" - the onyl difference is how many bits bep red, green and */
+/* "truecolor" - the only difference is how many bits bep red, green and */
/* blue channel. This is for speed reasons */
FB_Mode *fb_setmode(int width, int height, int depth, int refresh);
/* returns the current fb mode being used in FB_Mode */
void
evas_fb_outbuf_fb_free(Outbuf *buf)
{
- /* FIXME: impliment */
+ /* FIXME: implement */
WRN("destroying fb info.. not implemented!!!! WARNING. LEAK!");
if (buf->priv.back_buf)
evas_cache_image_drop(&buf->priv.back_buf->cache_entry);
{
if (buf->priv.fb.fb)
{
- /* FIXME: need to impliment an fb call for "copy area" */
+ /* FIXME: need to implement an fb call for "copy area" */
}
}
}
}
if (buf->priv.fb.fb)
{
- /* FIXME: impliment this */
+ /* FIXME: implement this */
}
/* if backbuf delet it */
/* resize window or reset fb mode */
}
else
{
-// FIXME: this doesnt work.. why oh why?
+// FIXME: this doesn't work.. why oh why?
int sx, sy, sw, sh;
// fimxe - reset when done
eim = (SDL_Engine_Image_Entry *) evas_cache_engine_image_alone(&eim->cache_entry,
NULL);
- /* FIXME: Handle colorspace convertion correctly. */
+ /* FIXME: Handle colorspace conversion correctly. */
if (image_data) *image_data = (DATA32 *) im->pixels;
return eim;
if (!eim) return NULL;
im = (Soft16_Image *) eim->cache_entry.src;
- /* FIXME: Handle colorspace convertion correctly. */
+ /* FIXME: Handle colorspace conversion correctly. */
if ((DATA16 *) image_data == im->pixels) return eim;
eim_new = (SDL_Engine_Image_Entry *) evas_cache_engine_image_data(re->cache,
eng_image_map4_draw,
eng_image_map_surface_new,
eng_image_map_surface_free,
- NULL, // eng_image_content_hint_set - software doesnt use it
- NULL // eng_image_content_hint_get - software doesnt use it
+ NULL, // eng_image_content_hint_set - software doesn't use it
+ NULL // eng_image_content_hint_get - software doesn't use it
/* FUTURE software generic calls go here */
};
if (fread(&g, 1, 1, f) != 1) goto close_file;
if (fread(&r, 1, 1, f) != 1) goto close_file;
if ((head_size != 12) /*&& (palette_size != 0)*/)
- { // OS/2 V1 doesnt do the pad byte
+ { // OS/2 V1 doesn't do the pad byte
if (fread(&a, 1, 1, f) != 1) goto close_file;
}
a = 0xff; // fillin a as solid for paletted images
footer = (tga_footer *)(filedata + (ss.st_size - sizeof(tga_footer)));
if (!memcmp(footer->signature, TGA_SIGNATURE, sizeof(footer->signature)))
{
- // footer is ther and matches. this is a tga file - any problems now
+ // footer is there and matches. this is a tga file - any problems now
// are a corrupt file
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
footer_present = 1;
footer = (tga_footer *)(filedata + (ss.st_size - sizeof(tga_footer)));
if (!memcmp(footer->signature, TGA_SIGNATURE, sizeof(footer->signature)))
{
- // footer is ther and matches. this is a tga file - any problems now
+ // footer is there and matches. this is a tga file - any problems now
// are a corrupt file
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
footer_present = 1;
projects / framework / uifw / evas.git / commitdiff