Shm_Handle *
cserve2_shm_resize(Shm_Handle *shm, size_t newsize)
{
size_t map_size;
int fd;
if (!shm)
return NULL;
if (shm->map_offset || shm->image_offset)
{
CRI("Can not resize shm with non-zero offset");
return NULL;
}
if (eina_inlist_count(shm->mapping->segments) > 1)
{
CRI("Can not resize shm with more than one segment");
return NULL;
}
fd = shm_open(shm->mapping->name, O_RDWR, S_IRUSR | S_IWUSR);
if (fd == -1)
{
ERR("Could not reopen shm handle: %m");
return NULL;
}
map_size = cserve2_shm_size_normalize(newsize, 0);
if (ftruncate(fd, map_size))
{
ERR("Could not set the size of the shm: %m");
close(fd);
return NULL;
}
if (shm->data)
{
munmap(shm->data, shm->image_size);
shm->data = mmap(NULL, shm->image_size, PROT_WRITE, MAP_SHARED,
fd, shm->image_offset);
}
close(fd);
shm->map_size = map_size;
shm->image_size = newsize;
shm->mapping->length = map_size;
return shm;
}
/* TODO: Documentation says "All implementations support the system-wide
* real-time clock, which is identified by CLOCK_REALTIME. Check if the fallback
* to unix time (without specifying the resolution) might be removed
*/
void
_ecore_time_init(void)
{
#if defined (HAVE_CLOCK_GETTIME) || defined (EXOTIC_PROVIDE_CLOCK_GETTIME)
struct timespec t;
if (_ecore_time_clock_id != -1) return;
if (!clock_gettime(CLOCK_MONOTONIC, &t))
{
_ecore_time_clock_id = CLOCK_MONOTONIC;
DBG("using CLOCK_MONOTONIC.");
}
else if (!clock_gettime(CLOCK_REALTIME, &t))
{
/* may go backwards */
_ecore_time_clock_id = CLOCK_REALTIME;
WRN("CLOCK_MONOTONIC not available. Fallback to CLOCK_REALTIME.");
}
else
{
_ecore_time_clock_id = -2;
CRI("Cannot get a valid clock_gettime() clock id! "
"Fallback to unix time.");
}
#else
# ifndef HAVE_EVIL
# if defined(__APPLE__) && defined(__MACH__)
mach_timebase_info_data_t info;
kern_return_t err = mach_timebase_info(&info);
if (err == 0)
{
_ecore_time_clock_conversion = 1e-9 * (double)info.numer / (double)info.denom;
}
else
{
WRN("Unable to get timebase info. Fallback to nanoseconds.");
}
# else
# warning "Your platform isn't supported yet"
CRI("Platform does not support clock_gettime. "
"Fallback to unix time.");
# endif
# endif
#endif
_ecore_time_loop_time = ecore_time_get();
}
EAPI void
e_icon_object_set(Evas_Object *obj, Evas_Object *o)
{
E_Smart_Data *sd;
const char *str;
if (evas_object_smart_smart_get(obj) != _e_smart) SMARTERR();
if (!(sd = evas_object_smart_data_get(obj))) return;
str = evas_object_type_get(o);
if ((!str) || strcmp(str, "image"))
CRI(EINA_COLOR_RED"******************\ntrying to set an image object of type '%s'! this is not what you want!\n******************\n"EINA_COLOR_RESET, str);
if (sd->timer) ecore_timer_del(sd->timer);
sd->timer = NULL;
if (sd->guessing_animation) ecore_timer_del(sd->guessing_animation);
sd->guessing_animation = NULL;
sd->frame = 0;
sd->frame_count = 0;
sd->edje = EINA_FALSE;
/* smart code here */
if (sd->obj) evas_object_del(sd->obj);
sd->loading = 0;
sd->obj = o;
evas_object_smart_member_add(sd->obj, obj);
if (evas_object_visible_get(obj)) evas_object_show(sd->obj);
_e_icon_smart_reconfigure(sd);
}
Eina_Bool
set_clip_name(char **name, char * text, int mode, int n)
{
Eina_Bool ret = EINA_TRUE;
/* Sanity check */
if (!text) {
WRN("ERROR: Text is NULL\n");
text = "";
}
/* to be continued latter */
if (name)
*name = _sanitize_ln(text, n, mode);
else {
ERR("Error: Clip name pointer is Null!!");
return EINA_FALSE;
}
if (!*name) {
/* This is bad, leave it to calling function */
CRI("ERROR: Memory allocation Failed!!");
ret = EINA_FALSE;
}
return ret;
}
/**
* @brief Validate a transmission attempt
*
* This function is used to check both the #Azy_Client_Call_Id and the #Azy_Content
* of an azy_client_call or azy_client_put attempt, and will additionally set
* an #Azy_Client_Return_Cb and log the calling function name upon failure.
* Note that this function also calls azy_content_error_reset.
* Also note: THIS FUNCTION IS MEANT TO BE USED IN A MACRO!!!!
* @param cli The client (NOT NULL)
* @param err_content The content used to make the call which may contain an error (NOT NULL)
* @param ret The call id
* @param cb The callback to set for @p ret (NOT NULL)
* @param func The function name of the calling function
* @return This function returns #EINA_TRUE only if the call was successful and @p cb was set, else #EINA_FALSE
*/
Eina_Bool
azy_client_call_checker(Azy_Client *cli,
Azy_Content *err_content,
Azy_Client_Call_Id ret,
Azy_Client_Return_Cb cb,
const char *func)
{
DBG("(cli=%p, cb=%p, func='%s')", cli, cb, func);
EINA_SAFETY_ON_NULL_RETURN_VAL(cli, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(err_content, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(cb, EINA_FALSE);
if (!ret) return EINA_FALSE;
if (azy_content_error_is_set(err_content))
{
ERR("%s:\n%s", func ? func : "<calling function not specified>", azy_content_error_message_get(err_content));
azy_content_error_reset(err_content);
return EINA_FALSE;
}
azy_content_error_reset(err_content);
if (!azy_client_callback_set(cli, ret, cb))
{
CRI("Could not set callback from %s!", func ? func : "<calling function not specified>");
return EINA_FALSE;
}
return EINA_TRUE;
}
/**
* Retrieves the current system time as a floating point value in seconds.
*
* This uses a monotonic clock and thus never goes back in time while
* machine is live (even if user changes time or timezone changes,
* however it may be reset whenever the machine is restarted).
*
* @see ecore_loop_time_get().
* @see ecore_time_unix_get().
*
* @return The number of seconds. Start time is not defined (it may be
* when the machine was booted, unix time, etc), all it is
* defined is that it never goes backwards (unless you got big critical
* messages when the application started).
*/
EAPI double
ecore_time_get(void)
{
#if defined (HAVE_CLOCK_GETTIME) || defined (EXOTIC_PROVIDE_CLOCK_GETTIME)
struct timespec t;
if (EINA_UNLIKELY(_ecore_time_clock_id < 0))
return ecore_time_unix_get();
if (EINA_UNLIKELY(clock_gettime(_ecore_time_clock_id, &t)))
{
CRI("Cannot get current time.");
/* Try to at least return the latest value retrieved*/
return _ecore_time_loop_time;
}
return (double)t.tv_sec + (((double)t.tv_nsec) / 1000000000.0);
#elif defined(HAVE_EVIL)
return evil_time_get();
#elif defined(__APPLE__) && defined(__MACH__)
return _ecore_time_clock_conversion * (double)mach_absolute_time();
#else
return ecore_time_unix_get();
#endif
}
static Eina_Bool
_bump_map_cpu_rgba_rgba(Evas_Filter_Command *cmd)
{
(void) cmd;
CRI("Not implemented yet.");
return EINA_FALSE;
}
EOLIAN static Eo *
_efl_ui_pager_efl_object_constructor(Eo *obj,
Efl_Ui_Pager_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "pager");
obj = efl_constructor(efl_super(obj, MY_CLASS));
if (elm_widget_theme_object_set(obj, wd->resize_obj,
elm_widget_theme_klass_get(obj),
elm_widget_theme_element_get(obj),
elm_widget_theme_style_get(obj)) == EFL_UI_THEME_APPLY_ERROR_GENERIC)
CRI("Failed to set layout!");
pd->cnt = 0;
pd->loop = EFL_UI_PAGER_LOOP_DISABLED;
pd->curr.page = -1;
pd->curr.pos = 0.0;
pd->transition = NULL;
pd->indicator = NULL;
pd->fill_width = EINA_TRUE;
pd->fill_height = EINA_TRUE;
pd->page_spec.sz.w = -1;
pd->page_spec.sz.h = -1;
elm_widget_can_focus_set(obj, EINA_TRUE);
pd->page_root = efl_add(EFL_CANVAS_GROUP_CLASS, evas_object_evas_get(obj));
efl_content_set(efl_part(obj, "efl.page_root"), pd->page_root);
efl_event_callback_add(pd->page_root, EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _resize_cb, pd);
efl_event_callback_add(pd->page_root, EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, _move_cb, pd);
pd->page_box = efl_add(EFL_UI_BOX_CLASS, obj);
efl_ui_widget_internal_set(pd->page_box, EINA_TRUE);
efl_canvas_group_member_add(pd->page_root, pd->page_box);
pd->foreclip = efl_add(EFL_CANVAS_RECTANGLE_CLASS,
evas_object_evas_get(obj));
efl_canvas_group_member_add(pd->page_root, pd->foreclip);
evas_object_static_clip_set(pd->foreclip, EINA_TRUE);
efl_canvas_object_clipper_set(pd->page_box, pd->foreclip);
pd->backclip = efl_add(EFL_CANVAS_RECTANGLE_CLASS,
evas_object_evas_get(obj));
efl_canvas_group_member_add(pd->page_root, pd->backclip);
evas_object_static_clip_set(pd->backclip, EINA_TRUE);
efl_gfx_entity_visible_set(pd->backclip, EINA_FALSE);
return obj;
}
static void
_block_events_theme_apply(Evas_Object *obj)
{
ELM_NOTIFY_DATA_GET(obj, sd);
const char *style = elm_widget_style_get(obj);
if (!elm_layout_theme_set
(sd->block_events, "notify", "block_events", style))
CRI("Failed to set layout!");
}
/*
* TSTENG_client_thread()
*
* Each client gets allocated a thread to handle all incoming
* messages
*/
static void *TSTENG_client_thread(void *args)
{
TSTENG_socket_msg_t msg;
TSTENG_client_t *client_p=NULL;
int len;
// get our client details
client_p = (TSTENG_client_t *) args;
if (client_p == NULL) {
ERR("failed to retrive client information\n");
return NULL;
}
INF("fd=%d client thread\n", client_p->fd);
while (1) {
len = OSA_RecvSocket(client_p->fd, &msg, sizeof(msg));
if (len == 0) {
INF("client disconnected\n");
break;
} else if (len == -1) {
if (errno != ECONNRESET)
CRI("unexpected error %d\n", errno);
break;
} else if (len > (int) sizeof(msg)) {
CRI("Invalid read length!!! %d\n", len);
exit(errno);
}
DBG("received command string %s on fd=%d \n", msg.testcase_str, client_p->fd);
TSTENG_handle_new_message(&msg, client_p);
}
TSTENG_remove_client(client_p->handle);
return NULL;
}
/*
* TSTENG_test_result_cb
*
* Called by sub-module under test to send time information to client
*/
void TSTENG_test_result_cb(TSTENG_handle_t handle, TSTENG_result_t result)
{
TSTENG_client_t *client_p=NULL;
TSTENG_socket_rtn_msg_t *msg_p=NULL;
int len;
if ((client_p = TSTENG_find_client(handle)) == NULL) {
ERR("invalid test handle\n");
return;
}
len = 0;
if (client_p->cmd_p != NULL) {
if (client_p->cmd_p->description != NULL) {
len = strlen(client_p->cmd_p->description);
}
}
if (len < 0) {
ERR("impossible!\n");
return;
}
msg_p = OSA_Malloc(sizeof(*msg_p) + len);
if (msg_p == NULL) {
CRI("unable to allocate memory\n");
return;
}
bzero(msg_p, sizeof(*msg_p) + len);
msg_p->type = TSTENG_RTN_RESULT;
msg_p->result = result;
msg_p->len = sizeof(*msg_p) + len;
if (len == 0)
msg_p->string = NULL;
else
memcpy(&(msg_p->string), client_p->cmd_p->description, len);
// XXX OSA_SocketSend
if (write(client_p->fd, msg_p, sizeof(*msg_p) + len) < 0) {
ERR("failed to write all data to client\n");
}
free(msg_p);
msg_p = NULL;
}
Eina_Bool
set_clip_content(char **content, char* text, int mode)
{
Eina_Bool ret = EINA_TRUE;
char *temp, *trim;
/* Sanity check */
if (!text) {
WRN("ERROR: Text is NULL\n");
text = "";
}
if (content) {
switch (mode) {
case 0:
/* Don't trim */
temp = strdup(text);
break;
case 1:
/* Trim new lines */
trim = strip_whitespace(text, TRIM_NEWLINES);
temp = strdup(trim);
break;
case 2:
/* Trim all white Space
* since white space includes new lines
* drop thru here */
case 3:
/* Trim white space and new lines */
trim = strip_whitespace(text, TRIM_SPACES);
temp = strdup(trim);
break;
default :
/* Error Don't trim */
WRN("ERROR: Invalid strip_mode %d\n", mode);
temp = strdup(text);
break;
}
if (!temp) {
/* This is bad, leave it to calling function */
CRI("ERROR: Memory allocation Failed!!");
ret = EINA_FALSE;
}
*content = temp;
} else
ERR("Error: Clip content pointer is Null!!");
return ret;
}
void
evas_outbuf_reconfigure(Evas_Engine_Info_Drm *info, Outbuf *ob, int w, int h)
{
int i = 0;
/* check for changes */
if ((ob->w == w) && (ob->h == h) &&
(ob->destination_alpha == info->info.destination_alpha) &&
(ob->rotation == info->info.rotation) &&
(ob->depth == info->info.depth))
return;
/* set new outbuf properties */
ob->rotation =info->info. rotation;
ob->depth = info->info.depth;
ob->destination_alpha = info->info.destination_alpha;
/* handle rotation */
if ((ob->rotation == 0) || (ob->rotation == 180))
{
ob->w = w;
ob->h = h;
if (ob->w < ob->priv.mode.hdisplay) ob->w = ob->priv.mode.hdisplay;
if (ob->h < ob->priv.mode.vdisplay) ob->h = ob->priv.mode.vdisplay;
}
else
{
ob->w = h;
ob->h = w;
if (ob->w < ob->priv.mode.vdisplay) ob->w = ob->priv.mode.vdisplay;
if (ob->h < ob->priv.mode.hdisplay) ob->h = ob->priv.mode.hdisplay;
}
/* destroy the old buffers */
for (; i < ob->priv.num; i++)
evas_drm_framebuffer_destroy(ob->priv.fd, &(ob->priv.buffer[i]));
for (i = 0; i < ob->priv.num; i++)
{
if (!_evas_outbuf_buffer_new(ob, &(ob->priv.buffer[i])))
{
CRI("Failed to create buffer");
break;
}
}
}
static Eina_Bool
_config_init(Email_Config *cfg)
{
Eina_Bool chk;
chk = eina_spinlock_new(&cfg->lock);
if (EINA_UNLIKELY(!chk))
{
CRI("Failed to create spinlock");
goto fail;
}
cfg->user_config = eina_hash_string_superfast_new(_free_cb);
return EINA_TRUE;
fail:
return EINA_FALSE;
}
/*
* TSTENG_test_info_cb
*
* Called by test cases to provide feedback during a test
*/
void TSTENG_test_info_cb(TSTENG_handle_t handle, TSTENG_result_t result, const char *str)
{
TSTENG_client_t *client=NULL;
TSTENG_socket_rtn_msg_t *msg=NULL;
int len;
client = TSTENG_find_client(handle);
if (client == NULL) {
ERR("invalid test handle\n");
return;
}
if (str != NULL)
len = strlen(str);
else
len = 0;
msg = OSA_Malloc(sizeof(*msg) + len);
if (msg == NULL) {
CRI("Unable to allocate enough memory\n");
return;
}
bzero(msg, sizeof(*msg) + len);
msg->type = TSTENG_RTN_INFO;
msg->result = result;
msg->len = sizeof(*msg) + len;
if (len == 0) {
msg->string = NULL;
} else {
memcpy(&(msg->string), str, len);
}
if (write(client->fd, msg, sizeof(*msg) + len) < 0) {
ERR("failed to write all data to client\n");
}
free(msg);
msg = NULL;
}
EAPI Eina_Bool
email_config_data_add(Email_Config *cfg,
const char *key,
void *data,
Eina_Free_Cb free_cb)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(cfg, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
Hash_Data *hd;
Eina_Bool chk;
hd = malloc(sizeof(*hd));
if (EINA_UNLIKELY(!hd))
{
CRI("Failed to allocate memory");
goto fail;
}
hd->data = data;
hd->free_cb = free_cb;
_config_lock(cfg);
chk = !!eina_hash_find(cfg->user_config, key);
if (EINA_UNLIKELY(chk == EINA_TRUE))
{
ERR("Element for key \"%s\" is already registered", key);
_config_unlock(cfg);
goto free;
}
chk = eina_hash_add(cfg->user_config, key, hd);
_config_unlock(cfg);
if (EINA_UNLIKELY(!chk))
goto free;
return chk;
free:
free(hd);
fail:
return EINA_FALSE;
}
static void
_eina_stringshare_small_del(const char *str, unsigned char length)
{
Eina_Stringshare_Small_Bucket **bucket;
const char *ret;
int i;
bucket = _eina_small_share.buckets + (unsigned char)str[0];
if (!*bucket)
goto error;
ret = _eina_stringshare_small_bucket_find(*bucket, str, length, &i);
if (!ret)
goto error;
_eina_stringshare_small_bucket_remove_at(bucket, i);
return;
error:
CRI("EEEK trying to del non-shared stringshare \"%s\"", str);
}
EAPI void
eina_stringshare_del(Eina_Stringshare *str)
{
int slen;
if (!str)
return;
/* special cases */
if (str[0] == '\0')
slen = 0;
else if (str[1] == '\0')
slen = 1;
else if (str[2] == '\0')
slen = 2;
else if (str[3] == '\0')
slen = 3;
else
slen = 4; /* handled later */
if (slen < 2)
{
eina_share_common_population_del(stringshare_share, slen);
return;
}
else if (slen < 4)
{
eina_share_common_population_del(stringshare_share, slen);
eina_spinlock_take(&_mutex_small);
_eina_stringshare_small_del(str, slen);
eina_spinlock_release(&_mutex_small);
return;
}
if (!eina_share_common_del(stringshare_share, str))
CRI("EEEK trying to del non-shared stringshare \"%s\"", str);
}
/*
* TSTENG_server_thread
*
* Single thread to bring up server port and accept new clients
*/
static void *TSTENG_server_thread(void *args)
{
int skt;
int on = 1;
struct sockaddr_in svraddr, cliaddr;
TSTENG_client_t *pl_client_t=NULL;
struct sockaddr *pl_soc=NULL;
args=args;
INF("bringing up test engine...\n");
// allocate a socket fd
if ((skt = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
CRI("TSTENG_server_thread: unable to create a socket\n");
exit(errno);
}
// setup port information
svraddr.sin_family = AF_INET;
svraddr.sin_port = htons(TSTENG_port_no);
svraddr.sin_addr.s_addr = htonl(INADDR_ANY);
INF("starting on port %d\n", TSTENG_port_no);
memset(&(svraddr.sin_zero), '\0', 8);
// allow us to re-use a public facing port
if (setsockopt(skt, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int)) < 0) {
CRI("unable to set socket options\n");
exit(errno);
}
// request port
if (bind(skt, (struct sockaddr *) &svraddr, sizeof(*pl_soc)) < 0) {
CRI("socket bind failed\n");
exit(errno);
}
// start listening for incoming messages
if (listen(skt, TSTENG_MAX_CLIENT) != 0) {
CRI("cant listen on socket");
exit(errno);
}
INF("ready to accept clients...\n");
while (1) {
int fd;
TSTENG_client_t *client_p;
socklen_t len = sizeof(*pl_soc);
// wait for new client
if ((fd = accept(skt, (struct sockaddr *) &cliaddr, &len)) == -1) {
INF("accept gives error...\n");
ERR("Socket accept\n");
exit(errno);
}
INF("socket accepted new connection, create client fd = %d\n", fd);
// allocate client info
if ((client_p = OSA_Malloc(sizeof(*pl_client_t))) == NULL) {
CRI("Unable to allocate memory\n");
close(fd);
continue;
}
client_p->fd = fd;
client_p->handle = fd; // for now, may need to pass handle in the msg from the LTP process
client_p->next = NULL;
TSTENG_add_client(client_p);
(void) OSA_ThreadCreate(client_p->thread, TSTENG_client_thread, (void *) client_p);
}
// if we ever get here, try and close down everything
// gracefully
TSTENG_close_down();
INF("closing down socket\n");
(void) close(skt);
}
Evas_Filter_Buffer *
evas_filter_buffer_scaled_get(Evas_Filter_Context *ctx,
Evas_Filter_Buffer *src,
unsigned w, unsigned h)
{
Evas_Filter_Buffer *fb;
Image_Entry *dstdata = NULL;
Image_Entry *srcdata;
void *drawctx;
srcdata = evas_filter_buffer_backing_get(ctx, src->id);
EINA_SAFETY_ON_NULL_RETURN_VAL(srcdata, NULL);
if (src->alpha_only)
{
// There is no supporting function in Evas for alpha scaling...
// but guess what? There is also no use case in the filters :)
CRI("Alpha buffer scaling is not supported");
return NULL;
}
fb = evas_filter_temporary_buffer_get(ctx, w, h, src->alpha_only);
if (!fb) return NULL;
dstdata = evas_filter_buffer_backing_get(ctx, fb->id);
if (!dstdata)
{
CRI("No backing found for buffer %d", fb->id);
return NULL;
}
if ((dstdata->w != w) || (dstdata->h != h))
{
CRI("Buffer size mismatch: got %dx%d requested %dx%d",
dstdata->w, dstdata->h, w, h);
return NULL;
}
if (ctx->gl_engine)
{
RGBA_Image *s = (RGBA_Image *) srcdata;
RGBA_Image *d = (RGBA_Image *) dstdata;
EINA_SAFETY_ON_NULL_RETURN_VAL(s->image.data, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(d->image.data, NULL);
if (src->w == (int) w && src->h == (int) h)
memcpy(d->image.data, s->image.data, w * h * 4);
else
{
Eina_Bool ok;
RGBA_Draw_Context dc;
memset(&dc, 0, sizeof(dc));
dc.sli.h = 1;
dc.render_op = EVAS_RENDER_COPY;
ok = evas_common_scale_rgba_in_to_out_clip_smooth
(s, d, &dc, 0, 0, src->w, src->h, 0, 0, w, h);
if (!ok)
{
ERR("RGBA Image scaling failed.");
return NULL;
}
}
}
else
{
drawctx = ENFN->context_new(ENDT);
ENFN->context_color_set(ENDT, drawctx, 255, 255, 255, 255);
ENFN->context_render_op_set(ENDT, drawctx, EVAS_RENDER_COPY);
ENFN->image_draw(ENDT, drawctx, dstdata, srcdata,
0, 0, src->w, src->h, // src
0, 0, w, h, // dst
EINA_TRUE, // smooth
EINA_FALSE); // Not async
ENFN->context_free(ENDT, drawctx);
}
return fb;
}
uint16_t
tile_mask_calculate(uint8_t tl,
uint8_t tr,
uint8_t bl,
uint8_t br)
{
/* Helpers */
#define TILE_HAS(type) _tile_has_type(tl, tr, bl, br, type)
#define LOW_MASK(first) _tile_boundry_low_mask_get(tl, tr, bl, br, first)
uint16_t tile = 0x0000;
if (tile_solid_is(tl, tr, bl, br))
{
switch (tl & 0x0f) /* tl == tr == bl == br */
{
case TILE_WATER_LIGHT: tile = 0x0010; break;
case TILE_WATER_DARK: tile = 0x0020; break;
case TILE_GROUND_LIGHT: tile = 0x0030; break;
case TILE_GROUND_DARK: tile = 0x0040; break;
case TILE_GRASS_LIGHT: tile = 0x0050; break;
case TILE_GRASS_DARK: tile = 0x0060; break;
case TILE_TREES: tile = 0x0070; break;
case TILE_ROCKS: tile = 0x0080; break;
case TILE_HUMAN_WALL:
tile = (tl & TILE_WALL_OPEN) ? 0x00b0 : 0x0090;
break;
case TILE_ORC_WALL:
tile = (tl & TILE_WALL_OPEN) ? 0x00c0 : 0x00a0;
break;
default:
CRI("Unhandled solid tile %x", tl);
goto fail;
}
}
else
{
if (TILE_HAS(TILE_GRASS_LIGHT))
{
if (TILE_HAS(TILE_TREES))
{
tile = 0x0700 | LOW_MASK(TILE_TREES);
}
else if (TILE_HAS(TILE_GRASS_DARK))
{
tile = 0x0600 | LOW_MASK(TILE_GRASS_DARK);
}
else if (TILE_HAS(TILE_GROUND_LIGHT))
{
tile = 0x0500 | LOW_MASK(TILE_GROUND_LIGHT);
}
else
{
CRI("Invalid disposition of tiles (with grass light)");
goto fail;
}
}
else if (TILE_HAS(TILE_GROUND_LIGHT))
{
if (TILE_HAS(TILE_GROUND_DARK))
{
tile = 0x0300 | LOW_MASK(TILE_GROUND_DARK);
}
else if (TILE_HAS(TILE_ROCKS))
{
tile = 0x0400 | LOW_MASK(TILE_ROCKS);
}
else if (TILE_HAS(TILE_WATER_LIGHT))
{
tile = 0x0200 | LOW_MASK(TILE_WATER_LIGHT);
}
else
{
CRI("Invalid disposition of tiles (with ground light)");
goto fail;
}
}
else if (TILE_HAS(TILE_WATER_LIGHT))
{
if (TILE_HAS(TILE_WATER_DARK))
{
tile = 0x0100 | LOW_MASK(TILE_WATER_DARK);
}
else
{
CRI("Invalid disposition of tiles (with water light)");
goto fail;
}
}
else if (TILE_HAS(TILE_ORC_WALL))
{
tile = 0x0900 | _tile_wall_mask_get(tl, tr, bl, br);
}
else if (TILE_HAS(TILE_HUMAN_WALL))
{
tile = 0x0800 | _tile_wall_mask_get(tl, tr, bl, br);
}
else
{
CRI("Uncovered tile disposition");
goto fail;
}
}
return tile;
fail:
CRI("Analysis of tile (tl, tr, bl, br) = (0x%02x, 0x%02x, 0x%02x, 0x%02x) failed",
tl, tr, bl, br);
return 0x0000;
#undef LOW_MASK
#undef TILE_HAS
}
int
evas_common_rgba_image_colorspace_set(Image_Entry* ie, Evas_Colorspace cspace)
{
RGBA_Image *im = (RGBA_Image *) ie;
// FIXME: This function looks extremely dubious now, trying to free the
// data pointer without even knowing how it was allocated (malloc / mmap).
// Also, lacks support for S3TC and exotic formats.
if (im->cache_entry.space == cspace)
return 1;
if (ie->references > 1)
WRN("Releasing data of image with >1 refs. Bad things may happen.");
if (im->cs.data)
{
if (!im->cs.no_free) free(im->cs.data);
im->cs.data = NULL;
}
im->cs.no_free = 0;
if (im->image.data && !im->image.no_free)
{
// FIXME: Call _evas_common_rgba_image_surface_munmap
free(im->image.data);
}
ie->allocated.w = 0;
ie->allocated.h = 0;
ie->flags.preload_done = 0;
ie->flags.loaded = 0;
im->image.data = NULL;
im->image.no_free = 0;
switch (cspace)
{
case EVAS_COLORSPACE_ARGB8888:
case EVAS_COLORSPACE_AGRY88:
case EVAS_COLORSPACE_GRY8:
// all good
break;
case EVAS_COLORSPACE_ETC1:
case EVAS_COLORSPACE_ETC1_ALPHA:
case EVAS_COLORSPACE_RGB8_ETC2:
case EVAS_COLORSPACE_RGBA8_ETC2_EAC:
// living on the edge (no conversion atm)
break;
case EVAS_COLORSPACE_YCBCR422P601_PL:
case EVAS_COLORSPACE_YCBCR422P709_PL:
case EVAS_COLORSPACE_YCBCR422601_PL:
case EVAS_COLORSPACE_YCBCR420TM12601_PL:
case EVAS_COLORSPACE_YCBCR420NV12601_PL:
// prepare cspace conversion buffer
im->cs.data = calloc(1, im->cache_entry.h * sizeof(unsigned char *) * 2);
im->cs.no_free = 0;
break;
default:
CRI("Can't set colorspace to %u: unsupported", (unsigned) cspace);
abort();
return 0;
}
im->cache_entry.space = cspace;
evas_common_image_colorspace_dirty(im);
_evas_common_rgba_image_post_surface(ie);
return 1;
}
EAPI int
eio_shutdown(void)
{
Eio_File_Direct_Info *info;
Eio_File_Char *cin;
Eio_Progress *pg;
Eio_File_Associate *asso;
Eio_File *f;
Eina_List *l;
if (_eio_init_count <= 0)
{
ERR("Init count not greater than 0 in shutdown.");
return 0;
}
if (--_eio_init_count != 0)
return _eio_init_count;
eina_log_timing(_eio_log_dom_global,
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
efl_del(io_manager);
io_manager = NULL;
EINA_LIST_FOREACH(tracked_thread, l, f)
ecore_thread_cancel(f->thread);
EINA_LIST_FREE(tracked_thread, f)
{
if (!ecore_thread_wait(f->thread, 0.5))
CRI("We couldn't terminate in less than 30s some pending IO. This can led to some crash.");
}
efreet_mime_shutdown();
eio_monitor_shutdown();
eina_condition_free(&(memory_pool_cond));
eina_lock_free(&(memory_pool_mutex));
eina_spinlock_free(&(memory_pool_lock));
eina_lock_free(&(direct_info_pool.lock));
eina_lock_free(&(progress_pool.lock));
eina_lock_free(&(char_pool.lock));
eina_lock_free(&(associate_pool.lock));
/* Cleanup pool */
EINA_TRASH_CLEAN(&progress_pool.trash, pg)
free(pg);
progress_pool.count = 0;
EINA_TRASH_CLEAN(&direct_info_pool.trash, info)
free(info);
direct_info_pool.count = 0;
EINA_TRASH_CLEAN(&char_pool.trash, cin)
free(cin);
char_pool.count = 0;
EINA_TRASH_CLEAN(&associate_pool.trash, asso)
free(asso);
associate_pool.count = 0;
ecore_shutdown();
eina_log_domain_unregister(_eio_log_dom_global);
_eio_log_dom_global = -1;
eina_shutdown();
return _eio_init_count;
}
EAPI_MAIN int
elm_main(int argc,
char **argv)
{
int ret = EXIT_FAILURE;
int args;
int i;
Editor *ed;
unsigned int ed_count = 0;
Eina_Bool quit_opt = EINA_FALSE;
Eina_Bool debug = EINA_FALSE;
Ecore_Getopt_Value values[] = {
ECORE_GETOPT_VALUE_BOOL(debug),
ECORE_GETOPT_VALUE_BOOL(quit_opt),
ECORE_GETOPT_VALUE_BOOL(quit_opt)
};
const Module *mod_ptr;
const Module *mod_end = &(_modules[EINA_C_ARRAY_LENGTH(_modules)]);
const char *env;
unsigned int debug_flags = 0;
args = ecore_getopt_parse(&_options, values, argc, argv);
if (args < 0)
{
EINA_LOG_CRIT("Getopt failed");
goto end;
}
/* Quit option requested? End now, with success */
if (quit_opt)
{
ret = EXIT_SUCCESS;
goto end;
}
if (debug)
debug_flags = ~0U;
/* Are we running in tree? */
env = getenv("WAR2EDIT_IN_TREE");
_in_tree = (env) ? !!atoi(env) : EINA_FALSE;
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
elm_language_set("");
elm_app_compile_bin_dir_set(PACKAGE_BIN_DIR);
elm_app_compile_lib_dir_set(PACKAGE_LIB_DIR);
elm_app_compile_data_dir_set(PACKAGE_DATA_DIR);
elm_app_info_set(elm_main, "war2edit", "sprites/units/units.eet");
if (EINA_UNLIKELY(!_edje_get(NULL)))
{
EINA_LOG_CRIT("Failed to get edje theme");
goto end;
}
for (mod_ptr = _modules; mod_ptr != mod_end; ++mod_ptr)
{
if (EINA_UNLIKELY(EINA_FALSE == mod_ptr->init()))
{
EINA_LOG_CRIT("Failed to initialize module \"%s\"", mod_ptr->name);
goto modules_shutdown;
}
}
/* Open editors for each specified files */
for (i = args; i < argc; ++i)
{
/* If an editor fails to open, don't close now */
ed = editor_new(argv[i], debug_flags);
if (!ed)
ERR("Failed to create editor with file \"%s\"", argv[i]);
else
++ed_count;
}
if (ed_count == 0)
{
ed = editor_new(NULL, debug_flags);
if (EINA_UNLIKELY(!ed))
{
CRI("Failed to create editor");
goto modules_shutdown;
}
}
/* === Main loop === */
elm_run();
ret = EXIT_SUCCESS;
modules_shutdown:
for (--mod_ptr; mod_ptr >= _modules; --mod_ptr)
mod_ptr->shutdown();
end:
if (_edje_file)
{
free(_edje_file);
_edje_file = NULL;
}
return ret;
}
void
tile_decompose(uint16_t tile_code,
uint8_t *tl,
uint8_t *tr,
uint8_t *bl,
uint8_t *br,
uint8_t *seed)
{
/*
* FIXME Algo here is sh*t.
*/
/* Seed is common to all tiles */
*seed = (uint8_t)(tile_code & 0x000f);
if ((tile_code & 0xff00) == 0x0000) /* Solid */
{
uint8_t code = TILE_NONE;
switch (tile_code & 0x00f0)
{
case 0x0010: code = TILE_WATER_LIGHT; break;
case 0x0020: code = TILE_WATER_DARK; break;
case 0x0030: code = TILE_GROUND_LIGHT; break;
case 0x0040: code = TILE_GROUND_DARK; break;
case 0x0050: code = TILE_GRASS_LIGHT; break;
case 0x0060: code = TILE_GRASS_DARK; break;
case 0x0070: code = TILE_TREES; break;
case 0x0080: code = TILE_ROCKS; break;
case 0x0090: code = TILE_HUMAN_WALL | TILE_WALL_CLOSED; break;
case 0x00b0: code = TILE_HUMAN_WALL | TILE_WALL_OPEN; break;
case 0x00a0: code = TILE_ORC_WALL | TILE_WALL_CLOSED; break;
case 0x00c0: code = TILE_ORC_WALL | TILE_WALL_OPEN; break;
default: CRI("Unhandled tile: 0x%04x", tile_code); return;
}
*bl = code; *br = code; *tl = code; *tr = code;
}
else /* Boundry */
{
uint8_t pair[2];
const uint16_t master = (tile_code & 0x0f00);
const uint16_t spread = (tile_code & 0x00f0);
switch (master)
{
case 0x0900:
pair[1] = TILE_ORC_WALL; pair[0] = TILE_ORC_WALL; break;
case 0x0800:
pair[1] = TILE_HUMAN_WALL; pair[0] = TILE_HUMAN_WALL; break;
case 0x0700:
pair[1] = TILE_TREES; pair[0] = TILE_GRASS_LIGHT; break;
case 0x0600:
pair[1] = TILE_GRASS_DARK; pair[0] = TILE_GRASS_LIGHT; break;
case 0x0500:
pair[1] = TILE_GROUND_LIGHT; pair[0] = TILE_GRASS_LIGHT; break;
case 0x0400:
pair[1] = TILE_ROCKS; pair[0] = TILE_GROUND_LIGHT; break;
case 0x0300:
pair[1] = TILE_GROUND_DARK; pair[0] = TILE_GROUND_LIGHT; break;
case 0x0200:
pair[1] = TILE_WATER_LIGHT; pair[0] = TILE_GROUND_LIGHT; break;
case 0x0100:
pair[1] = TILE_WATER_DARK; pair[0] = TILE_WATER_LIGHT; break;
default:
CRI("Invalid tile 0x%04x (unhandled master 0x%04x)",
tile_code, master);
return;
}
/* Walls */
if ((pair[0] == TILE_ORC_WALL) || (pair[0] == TILE_HUMAN_WALL))
{
const uint8_t key = (spread >> 4) & 0xf;
uint8_t val;
if (EINA_UNLIKELY(key > 0xd))
{
CRI("Invalid wall spread 0x%04x", spread);
return;
}
val = _walls_table[key];
*tl = _wall_tile_gen((val >> 3) & 0x1) | pair[0];
*tr = _wall_tile_gen((val >> 2) & 0x1) | pair[0];
*bl = _wall_tile_gen((val >> 1) & 0x1) | pair[0];
*br = _wall_tile_gen(val & 0x1) | pair[0];
}
else /* Everything but walls */
{
switch (spread)
{
/* TL TR
* BL BR */
case 0x0000:
*tl = pair[1]; *tr = pair[0]; *bl = pair[0]; *br = pair[0]; break;
case 0x00d0:
*tl = pair[0]; *tr = pair[1]; *bl = pair[1]; *br = pair[1]; break;
case 0x0010:
*tl = pair[0]; *tr = pair[1]; *bl = pair[0]; *br = pair[0]; break;
case 0x00c0:
*tl = pair[1]; *tr = pair[0]; *bl = pair[1]; *br = pair[1]; break;
case 0x0020:
*tl = pair[1]; *tr = pair[1]; *bl = pair[0]; *br = pair[0]; break;
case 0x00b0:
*tl = pair[0]; *tr = pair[0]; *bl = pair[1]; *br = pair[1]; break;
case 0x0030:
*tl = pair[0]; *tr = pair[0]; *bl = pair[1]; *br = pair[0]; break;
case 0x00a0:
*tl = pair[1]; *tr = pair[1]; *bl = pair[0]; *br = pair[1]; break;
case 0x0040:
*tl = pair[1]; *tr = pair[0]; *bl = pair[1]; *br = pair[0]; break;
case 0x0090:
*tl = pair[0]; *tr = pair[1]; *bl = pair[0]; *br = pair[1]; break;
case 0x0070:
*tl = pair[0]; *tr = pair[0]; *bl = pair[0]; *br = pair[1]; break;
case 0x0060:
*tl = pair[1]; *tr = pair[1]; *bl = pair[1]; *br = pair[0]; break;
case 0x0080:
*tl = pair[1]; *tr = pair[0]; *bl = pair[0]; *br = pair[1]; break;
case 0x0050:
*tl = pair[0]; *tr = pair[1]; *bl = pair[1]; *br = pair[0]; break;
default:
CRI("Invalid tile 0x%04x (unhandled spread 0x%04x)",
tile_code, spread);
return;
}
}
}
