static Eina_File *
check_bc(Eina_File *of, const char *fname, Eina_Bool *bc)
{
if (of)
{
struct stat bc_stat, sc_stat;
/* original file doesn't exist, only bytecode does, use bytecode */
if (stat(fname, &sc_stat) < 0)
return of;
if (stat(eina_file_filename_get(of), &bc_stat) < 0)
{
/* what? */
eina_file_close(of);
goto generate;
}
/* bytecode is newer than original file, use bytecode */
if (bc_stat.st_mtime > sc_stat.st_mtime)
return of;
/* bytecode is not new enough; trigger regeneration */
eina_file_close(of);
}
generate:
*bc = EINA_TRUE;
return eina_file_open(fname, EINA_FALSE);
}
EAPI const char *elm_code_file_path_get(Elm_Code_File *file)
{
if (!file->file)
return NULL;
return eina_file_filename_get(file->file);
}
EAPI const char *elm_code_file_filename_get(Elm_Code_File *file)
{
if (!file->file)
return NULL;
return basename((char *)eina_file_filename_get(file->file));
}
/**
* @brief Function to retrieve supported languages.
*
* This function parses a xml file containing tvdb language data,
* and adds it to a hash table (which it initializes).
* The xml data will be downloaded, or (optionally) read from a file.
*
* If you no longer need the data, you'll have to free the hashtable
* (with eina_hash_free()), but not the data in the table.
*
* @param lang_file_path Path to a XML file containing TVDB's supported languages.
* This allows to provide a custom XML language file.
* It is recommended to pass NULL. In this case the languages.xml file provide with
* etvdb will be used and, if not available, the languages will be retrieved online.
*
* @return a pointer to a Eina hashtable on success, NULL on failure
*
* @ingroup Infrastructure
*/
EAPI Eina_Hash *etvdb_languages_get(const char *lang_file_path)
{
char uri[URI_MAX];
Download xml;
Eina_File *file = NULL;
Eina_Hash *hash = NULL;
Parser_Data pdata;
hash = eina_hash_string_superfast_new(_hash_free_cb);
if(!hash) {
ERR("Hash table not valid or initialized.");
return NULL;
}
/* use path passed to the function or default */
if (lang_file_path) {
file = eina_file_open(lang_file_path, EINA_FALSE);
}
else {
file = eina_file_open(DATA_LANG_FILE_XML, EINA_FALSE);
}
/* if no local file can be read, download xml data */
if (file) {
xml.len = eina_file_size_get(file);
xml.data = eina_file_map_all(file, EINA_FILE_POPULATE);
if(!xml.data)
return NULL;
DBG("Read %s file with size %d", eina_file_filename_get(file), (int)xml.len);
}
else {
snprintf(uri, URI_MAX, TVDB_API_URI"/%s/languages.xml", etvdb_api_key);
CURL_XML_DL_MEM(xml, uri) {
ERR("Couldn't get languages from server.");
return NULL;
}
}
static Eina_Bool
_load(Eina_File *ef, const char *key,
Evas_Image_Property *prop,
Evas_Image_Load_Opts *opts,
void *pixels,
int *error, Eina_Bool get_data)
{
Eina_Bool res = EINA_FALSE;
int w = 0, h = 0, alpha = 0;
const char *dot1 = NULL, *dot2 = NULL, *end, *p;
char *cmd = NULL, decoders[3][128], buf[4096];
char *loader = "/evas/utils/evas_image_loader";
char *img_loader = NULL;
const char *libdir;
// eg $libdir/evas/generic_loaders
int cmd_len, len, decoders_num = 0, try_count = 0;
int read_data = 0;
char *tmpfname = NULL, *shmfname = NULL;
DATA32 *body;
FILE *f = NULL;
libdir = _evas_module_libdir_get();
cmd_len = strlen(libdir);
cmd_len += strlen(loader);
img_loader = alloca(cmd_len + 1);
strcpy(img_loader, libdir);
strcat(img_loader, loader);
// params excluding file, key and loadopts
cmd_len += 1024;
cmd_len += strlen(eina_file_filename_get(ef)) * 2;
if (key) cmd_len += strlen(key) * 2;
cmd = alloca(cmd_len + 1);
len = strlen(eina_file_filename_get(ef));
if (len < 1)
{
*error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
return EINA_FALSE;
}
end = eina_file_filename_get(ef) + len;
for (p = end - 1; p >= eina_file_filename_get(ef); p--)
{
if ((!dot1) && (*p == '.')) dot1 = p;
else if ((!dot2) && (*p == '.')) dot2 = p;
else if ((dot1) && (dot2)) break;
}
if (dot2)
{
// double extn not too long
if (((end - dot2) <= 10) && (!illegal_char(dot2)))
{
strncpy(&(decoders[decoders_num][0]), img_loader, 127);
decoders[decoders_num][127] = 0;
dotcat(&(decoders[decoders_num][0]), dot2);
decoders_num++;
}
// single extn not too long
if (((end - dot1) <= 5) && (!illegal_char(dot1)))
{
strncpy(&(decoders[decoders_num][0]), img_loader, 127);
decoders[decoders_num][127] = 0;
dotcat(&(decoders[decoders_num][0]), dot1);
decoders_num++;
}
strncpy(decoders[decoders_num], img_loader, 127);
decoders[decoders_num][127] = 0;
decoders_num++;
}
else if (dot1)
{
// single extn not too long
if (((end - dot1) <= 5) && (!illegal_char(dot1)))
{
strncpy(&(decoders[decoders_num][0]), img_loader, 127);
decoders[decoders_num][127] = 0;
dotcat(&(decoders[decoders_num][0]), dot1);
decoders_num++;
}
strncpy(decoders[decoders_num], img_loader, 127);
decoders[decoders_num][127] = 0;
decoders_num++;
}
else
{
strncpy(decoders[decoders_num], img_loader, 127);
decoders[decoders_num][127] = 0;
decoders_num++;
}
for (try_count = 0; try_count < decoders_num; try_count++)
{
// FIXME: strcats could be more efficient, not that it matters much
// here as we are about to build a cmd to exec via a shell that
// will interpret shell stuff and path hunt that will then exec the
// program itself that will dynamically link that will again
// parse the arguments and finally do something...
if (access(decoders[try_count], X_OK)) continue;
strcpy(cmd, decoders[try_count]);
strcat(cmd, " ");
// filename first arg
len = strlen(cmd);
escape_copy(eina_file_filename_get(ef), cmd + len);
if (!get_data)
{
strcat(cmd, " -head ");
}
if (key)
{
strcat(cmd, " -key ");
len = strlen(cmd);
escape_copy(key, cmd + len);
}
if (opts->scale_down_by > 1)
{
strcat(cmd, " -opt-scale-down-by ");
snprintf(buf, sizeof(buf), "%i", opts->scale_down_by);
strcat(cmd, buf);
}
if (opts->dpi > 0.0)
{
strcat(cmd, " -opt-dpi ");
snprintf(buf, sizeof(buf), "%i", (int)(opts->dpi * 1000.0));
strcat(cmd, buf);
}
if ((opts->w > 0) &&
(opts->h > 0))
{
strcat(cmd, " -opt-size ");
snprintf(buf, sizeof(buf), "%i %i", opts->w, opts->h);
strcat(cmd, buf);
}
f = popen(cmd, "r");
if (f) break;
}
if (!f)
{
*error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
return EINA_FALSE;
}
while (fgets(buf, sizeof(buf), f))
{
len = strlen(buf);
if (len > 0)
{
if (buf[len - 1] == '\n') buf[len - 1] = 0;
if (!strncmp(buf, "size ", 5))
{
int tw = 0, th = 0;
len = sscanf(buf, "%*s %i %i", &tw, &th);
if (len == 2)
{
if ((tw > 0) && (th > 0))
{
w = tw;
h = th;
}
}
}
else if (!strncmp(buf, "alpha ", 6))
{
int ta;
len = sscanf(buf, "%*s %i", &ta);
if (len == 1)
{
alpha = ta;
}
}
else if (!strncmp(buf, "tmpfile ", 8))
{
tmpfname = buf + 8;
goto getdata;
}
#ifdef HAVE_SHM_OPEN
else if (!strncmp(buf, "shmfile ", 8))
{
shmfname = buf + 8;
goto getdata;
}
#endif
else if (!strncmp(buf, "data", 4))
{
read_data = 1;
goto getdata;
}
else if (!strncmp(buf, "done", 4))
{
read_data = 2;
goto getdata;
}
}
}
getdata:
if ((!read_data) && (!tmpfname) && (!shmfname))
{
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
goto on_error;
}
if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) ||
IMG_TOO_BIG(w, h))
{
*error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
goto on_error;
}
if (!get_data)
{
if (alpha) prop->alpha = 1;
prop->w = w;
prop->h = h;
}
else
{
if ((int)prop->w != w ||
(int)prop->h != h)
{
*error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
goto on_error;
}
body = pixels;
if ((tmpfname) || (shmfname))
{
int fd = -1;
// open
if (tmpfname)
fd = open(tmpfname, O_RDONLY, S_IRUSR);
#ifdef HAVE_SHM_OPEN
else if (shmfname)
fd = shm_open(shmfname, O_RDONLY, S_IRUSR);
#endif
if (fd >= 0)
{
void *addr;
eina_mmap_safety_enabled_set(EINA_TRUE);
// mmap
addr = mmap(NULL, w * h * sizeof(DATA32),
PROT_READ, MAP_SHARED, fd, 0);
if (addr != MAP_FAILED)
{
memcpy(body, addr, w * h * sizeof(DATA32));
munmap(addr, w * h * sizeof(DATA32));
}
// close
if (tmpfname)
{
close(fd);
unlink(tmpfname);
}
#ifdef HAVE_SHM_OPEN
else if (shmfname)
{
close(fd);
shm_unlink(shmfname);
}
#endif
}
else
{
*error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
goto on_error;
}
}
else if (read_data)
{
if (fread(body, w * h * sizeof(DATA32), 1, f) != 1)
{
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
goto on_error;
}
}
}
res = EINA_TRUE;
*error = EVAS_LOAD_ERROR_NONE;
on_error:
if (f) pclose(f);
return res;
}
void
evas_model_load_file_obj(Evas_Canvas3D_Mesh *mesh, Eina_File *file)
{
long i;
OBJ_Counts counts;//count elements of mesh in .obj
Eina_Bool will_check_next_char = EINA_FALSE;
Eina_Bool first_char_is_v = EINA_FALSE;
Eina_Bool first_char_is_f = EINA_FALSE;
float *pos = NULL, *nor = NULL, *tex = NULL;
int stride_pos = 0, stride_nor = 0, stride_tex = 0;
int j, k, data_for_one_point;
char *current, *map;
float *_vertices_obj = NULL, *_normales_obj = NULL, *_tex_coords_obj = NULL;
int *_triangles;
map = eina_file_map_all(file, EINA_FILE_SEQUENTIAL);
if (map == NULL)
{
ERR("Failed to create map from file %s\n", eina_file_filename_get(file));
return;
}
counts = _count_elements(map);
_vertices_obj = malloc(counts._vertex_counter * 3 * sizeof(float));
data_for_one_point = 1;
if (counts.existence_of_normal)
{
data_for_one_point++;
_normales_obj = malloc(counts._normal_counter * 3 * sizeof(float));
}
if (counts.existence_of_tex_point)
{
data_for_one_point++;
_tex_coords_obj = malloc(counts._texture_point_counter * 3 * sizeof(float));
}
_triangles = malloc(counts._triangles_counter * 9 * sizeof(int));
if ((map == NULL) || (_vertices_obj == NULL) || (_triangles == NULL) ||
((counts.existence_of_normal) && (_normales_obj == NULL)) ||
((counts.existence_of_tex_point) && (_tex_coords_obj == NULL)))
{
ERR("Allocate memory is failed.");
free(_vertices_obj);
free(_triangles);
if (counts.existence_of_normal)
free(_normales_obj);
if (counts.existence_of_tex_point)
free(_tex_coords_obj);
return;
}
current = map;
i = 0;
/* put data to arrays */
for (; *current != '\00'; i++)
{
if (will_check_next_char)
{
if (first_char_is_v)
{
switch (*current)
{
case ' ':
PUT_DATA_TO_ARRAY(vertices, vertex)
i--;
break;
case 't':
current++;
if (counts.existence_of_tex_point)
{
PUT_DATA_TO_ARRAY(tex_coords, texture_point)
}
break;
case 'n':
current++;
if (counts.existence_of_normal)
{
PUT_DATA_TO_ARRAY(normales, normal)
}
break;
default:
break;
}
first_char_is_v = EINA_FALSE;
will_check_next_char = EINA_FALSE;
}
else if (first_char_is_f)
{
char *auxiliary_pointer = current;
int count_of_triangles_in_line;
int the_first_point = counts.current_triangles_counter;
_analyze_face_line(auxiliary_pointer,
&count_of_triangles_in_line);
current++;
i++;
_read_point(_triangles, 1, counts,
the_first_point,
current);
AFTER_NEXT_SPACE(current)
for (j = 0; j < count_of_triangles_in_line; j++)
{
auxiliary_pointer = current;
if (counts.current_triangles_counter != the_first_point)
{
ARRAY_2D(_triangles, counts.current_triangles_counter, 0, 9) = \
ARRAY_2D(_triangles, the_first_point, 0, 9);
ARRAY_2D(_triangles, counts.current_triangles_counter, 1, 9) = \
ARRAY_2D(_triangles, the_first_point, 1, 9);
ARRAY_2D(_triangles, counts.current_triangles_counter, 2, 9) = \
ARRAY_2D(_triangles, the_first_point, 2, 9);
}
_read_point(_triangles, 2, counts,
counts.current_triangles_counter,
auxiliary_pointer);
AFTER_NEXT_SPACE(auxiliary_pointer);
_read_point(_triangles, 3, counts,
counts.current_triangles_counter,
auxiliary_pointer);
AFTER_NEXT_SPACE(current);
counts.current_triangles_counter++;
}
first_char_is_f = EINA_FALSE;
}
else
{
switch (*current)
{
case 'v':
first_char_is_v = EINA_TRUE;
break;
case 'f':
first_char_is_f = EINA_TRUE;
break;
case 'm':
will_check_next_char = EINA_FALSE;
break;
default:
will_check_next_char = EINA_FALSE;
break;
}
}
}
static Eina_Bool
_evas_image_file_header(Evas_Module *em, Image_Entry *ie, int *error)
{
Evas_Image_Load_Func *evas_image_load_func = NULL;
Eina_Bool r = EINA_TRUE;
if (!evas_module_load(em)) goto load_error;
evas_image_load_func = em->functions;
evas_module_use(em);
*error = EVAS_LOAD_ERROR_NONE;
if (evas_image_load_func)
{
Evas_Image_Property property;
const char *file;
if (!ie->f)
{
ie->f = eina_file_open(ie->file, EINA_FALSE);
file = ie->file;
}
else
{
file = eina_file_filename_get(ie->f);
}
if (!ie->f)
{
*error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
goto load_error;
}
ie->loader_data = evas_image_load_func->file_open(ie->f, ie->key,
&ie->load_opts,
&ie->animated,
error);
if (!ie->loader_data)
{
goto load_error;
}
memset(&property, 0, sizeof (Evas_Image_Property));
if (evas_image_load_func->file_head(ie->loader_data, &property,
error) &&
(*error == EVAS_LOAD_ERROR_NONE))
{
DBG("loaded file head using module '%s' (%p): %s",
em->definition->name, em, file);
ie->w = property.w;
ie->h = property.h;
ie->scale = property.scale;
ie->flags.alpha = property.alpha;
if (ie->load_opts.orientation &&
ie->load_opts.degree != 0)
ie->flags.rotated = EINA_TRUE;
r = EINA_FALSE;
}
else
{
evas_image_load_func->file_close(ie->loader_data);
ie->loader_data = NULL;
evas_module_unload(em);
INF("failed to load file head using module '%s' (%p): "
"%s (%s)",
em->definition->name, em, file, evas_load_error_str(*error));
}
}
else
{
load_error:
evas_module_unload(em);
WRN("failed to load module '%s'.", em->definition->name);
}
return r;
}
