static Eina_Bool
_elitaire_card_job_drag(Elitaire_Job_List * list, void * data)
{
int fr;
Elitaire_Card * ecard;
Elitaire_Card_Job * job;
job = (Elitaire_Card_Job *) data;
ecard = (Elitaire_Card *) evas_object_smart_data_get(job->card);
fr = ecard->eli->frame_rate;
evas_object_raise(job->card);
ecard->flying = true;
if (ecard->eli->shadow) {
_elitaire_card_shadow_on(job->card);
job->timer = ecore_animator_add(_elitaire_card_drag_cb, data);
}
else {
job->x.i = 1;
job->timer = ecore_animator_add(_elitaire_card_wait_time_cb, data);
}
return 0;
}
void animator_setup(animator_callback_gui_shared_info_s* common_data)
{
debug_only("%s","animator_setup");
ecore_animator_frametime_set(REFRESH_SPEED);
common_data->dash_animator = ecore_animator_add(animator_rotate_dashes, common_data);
common_data->balls_animator = ecore_animator_add(animator_spawns_balls, common_data);
ecore_animator_freeze(common_data->dash_animator);
ecore_animator_freeze(common_data->balls_animator);
}
/**
* Set up connections, signal handlers, sockets etc.
* @return 1 or greater on success, 0 otherwise
*
* This function sets up all singal handlers and the basic event loop. If it
* succeeds, 1 will be returned, otherwise 0 will be returned.
*
* @code
* #include <Ecore.h>
*
* int main(int argc, char **argv)
* {
* if (!ecore_init())
* {
* printf("ERROR: Cannot init Ecore!\n");
* return -1;
* }
* ecore_main_loop_begin();
* ecore_shutdown();
* }
* @endcode
*/
EAPI int ecore_init(void)
{
if (++_ecore_init_count != 1)
return _ecore_init_count;
#ifdef HAVE_LOCALE_H
setlocale(LC_CTYPE, "");
#endif
/*
if (strcmp(nl_langinfo(CODESET), "UTF-8"))
{
WRN("Not a utf8 locale!");
}
*/
#ifdef HAVE_EVIL
if (!evil_init())
return --_ecore_init_count;
#endif
if (!eina_init())
goto shutdown_evil;
_ecore_log_dom =
eina_log_domain_register("Ecore", ECORE_DEFAULT_LOG_COLOR);
if (_ecore_log_dom < 0) {
EINA_LOG_ERR("Ecore was unable to create a log domain.");
goto shutdown_log_dom;
}
if (getenv("ECORE_FPS_DEBUG"))
_ecore_fps_debug = 1;
if (_ecore_fps_debug)
_ecore_fps_debug_init();
_ecore_main_loop_init();
_ecore_signal_init();
_ecore_exe_init();
_ecore_thread_init();
_ecore_glib_init();
_ecore_job_init();
_ecore_time_init();
#if HAVE_MALLINFO
if (getenv("ECORE_MEM_STAT")) {
_ecore_memory_pid = getpid();
ecore_animator_add(_ecore_memory_statistic, NULL);
}
#endif
#if defined(GLIB_INTEGRATION_ALWAYS)
if (_ecore_glib_always_integrate)
ecore_main_loop_glib_integrate();
#endif
return _ecore_init_count;
shutdown_log_dom:
eina_shutdown();
shutdown_evil:
#ifdef HAVE_EVIL
evil_shutdown();
#endif
return --_ecore_init_count;
}
void XmasWidget::Show()
{
edje_object_signal_emit(edje, "enable", "calaos");
EdjeObject::Show();
if (animator) ecore_animator_del(animator);
animator = ecore_animator_add(_snow_cb_animator, this);
}
static void
_elitaire_card_job_timer_add(Elitaire_Job_List * list, void * data,
int (*func) (void *))
{
Elitaire_Card_Job * job;
job = (Elitaire_Card_Job *) data;
job->timer = ecore_animator_add(func, data);
}
EAPI void
_emotion_frame_new(Evas_Object *obj)
{
Smart_Data *sd;
E_SMART_OBJ_GET(sd, obj, E_OBJ_NAME);
if (!sd->anim) sd->anim = ecore_animator_add(_emotion_frame_anim, obj);
}
static void
mouse_down_arrow_down(void *d, Evas *e, Evas_Object *obj, void *event_info)
{
app_t *app = d;
if (app->mouse_down_anim)
ecore_animator_del(app->mouse_down_anim);
app->mouse_down_anim = ecore_animator_add(do_move_down, app);
move_down(app);
}
PREFIX value ml_ecore_animator_add(value v_fun)
{
value* data = ml_register_value(v_fun);
Ecore_Animator* anim =
ecore_animator_add(ml_Ecore_Task_Cb_free_on_last, data);
if(anim == NULL) {
ml_remove_value(data);
caml_failwith("ecore_animator_add");
}
return Val_Ecore_Animator(anim);
}
static bool
app_create(void *data)
{
appdata_s *ad = data;
cairo_evasgl_drawing(ad);
ecore_animator_frametime_set(0.016);
ecore_animator_add(_animate_cb, (void *)ad->img);
eext_rotary_event_handler_add(_rotary_handler_cb, ad);
return true;
}
static void
scroll_setup(app_t *app, int dir)
{
gettimeofday(&app->scroll.start, NULL);
scroll_init(app, &app->scroll.start, dir);
if (app->scroll.delay_ms < MINIMUM_SCROLL_DELAY) {
app->scroll.last = app->scroll.start;
scroll_ended(app);
return;
}
app->scroll.anim = ecore_animator_add(scroll, app);
}
static Eina_Bool
_elitaire_card_job_wait_time(Elitaire_Job_List * list, void * data)
{
int fr;
Elitaire_Card * ecard;
Elitaire_Card_Job * job;
job = (Elitaire_Card_Job *) data;
ecard = (Elitaire_Card *) evas_object_smart_data_get(job->card);
fr = ecard->eli->frame_rate;
ecard->waiting = true;
job->timer = ecore_animator_add(_elitaire_card_wait_time_cb, data);
return 0;
}
static void
_rotate_go(Smart_Data *sd, unsigned char mode)
{
char inc = 1;
if (!sd->animator) sd->animator = ecore_animator_add(_rotate, sd);
sd->start = ecore_loop_time_get();
if (!mode)
inc = -1;
sd->state += inc;
if (sd->state < 0)
sd->state = 3;
else if (sd->state > 3)
sd->state = 0;
sd->mode = mode;
}
static Eina_Bool
_elitaire_card_job_drop(Elitaire_Job_List * list, void * data)
{
int fr;
Elitaire_Card * ecard;
Elitaire_Card_Job * job;
job = (Elitaire_Card_Job *) data;
ecard = (Elitaire_Card *) evas_object_smart_data_get(job->card);
fr = ecard->eli->frame_rate;
ecard->flying = false;
if (ecard->eli->shadow) ecore_animator_add(_elitaire_card_drop_cb, data);
else {
//elitaire_card_chain_del(job->card);
elitaire_stack_layer_reinit(ecard->eli, ecard->pcard);
return 1;
}
return 0;
}
static int
EvasDisplayMainloopCb( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
if( sys->b_evas_changed || sys->pf_set_data( vd ) )
return -1;
evas_object_image_data_update_add( sys->p_evas, 0, 0,
sys->i_width, sys->i_height );
evas_object_image_pixels_dirty_set( sys->p_evas, 0 );
if( !sys->p_anim )
sys->p_anim = ecore_animator_add( mainloop_evas_anim_cb, vd );
if( sys->p_current_buffer )
BUFFER_FIFO_PUSH( sys->p_current_buffer );
sys->p_current_buffer = sys->p_new_buffer;
sys->p_new_buffer = NULL;
return 0;
}
EAPI_MAIN int
elm_main(int argc, char **argv)
{
Evas_Object *win, *bg, *bx, *bt, *gl;
Ecore_Animator *ani;
GLData *gld = NULL;
if (!(gld = calloc(1, sizeof(GLData)))) return 1;
// set the engine to opengl_x11
// if commented out, ELM will choose one
elm_config_engine_set("opengl_x11");
win = elm_win_add(NULL, "glview simple", ELM_WIN_BASIC);
elm_win_title_set(win, "GLView Simple");
elm_win_autodel_set(win, EINA_TRUE);
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
bg = elm_bg_add(win);
elm_win_resize_object_add(win, bg);
evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(bg);
bx = elm_box_add(win);
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_win_resize_object_add(win, bx);
evas_object_show(bx);
//-//-//-// THIS IS WHERE GL INIT STUFF HAPPENS (ALA EGL)
//-//
// create a new glview object
gl = elm_glview_add(win);
gld->glapi = elm_glview_gl_api_get(gl);
evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
// mode is simply for supporting alpha, depth buffering, and stencil
// buffering.
elm_glview_mode_set(gl, ELM_GLVIEW_ALPHA | ELM_GLVIEW_DEPTH);
// resize policy tells glview what to do with the surface when it
// resizes. ELM_GLVIEW_RESIZE_POLICY_RECREATE will tell it to
// destroy the current surface and recreate it to the new size
elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
// render policy tells glview how it would like glview to render
// gl code. ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the gl
// calls called in the pixel_get callback, which only gets called
// if the object is visible, hence ON_DEMAND. ALWAYS mode renders
// it despite the visibility of the object.
elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
// initialize callback function gets registered here
elm_glview_init_func_set(gl, _init_gl);
// delete callback function gets registered here
elm_glview_del_func_set(gl, _del_gl);
elm_glview_resize_func_set(gl, _resize_gl);
elm_glview_render_func_set(gl, _draw_gl);
//-//
//-//-//-// END GL INIT BLOB
elm_box_pack_end(bx, gl);
evas_object_show(gl);
elm_object_focus_set(gl, EINA_TRUE);
// animating - just a demo. as long as you trigger an update on the image
// object via elm_glview_changed_set() it will be updated.
//
// NOTE: if you delete gl, this animator will keep running trying to access
// gl so you'd better delete this animator with ecore_animator_del().
ani = ecore_animator_add(_anim, gl);
evas_object_data_set(gl, "ani", ani);
evas_object_data_set(gl, "gld", gld);
evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, _del, gl);
// add an 'OK' button to end the program
bt = elm_button_add(win);
elm_object_text_set(bt, "OK");
evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
elm_box_pack_end(bx, bt);
evas_object_show(bt);
evas_object_smart_callback_add(bt, "clicked", _on_done, win);
evas_object_resize(win, 320, 480);
evas_object_show(win);
// run the mainloop and process events and callbacks
elm_run();
elm_shutdown();
return 0;
}
Animator::Animator()
{
Dout( dc::notice, "Animator::Animator() - current frametime is " << frameTime() );
_ea = ecore_animator_add( &Animator::__dispatcher, this );
}
static void
_init_glview(Evas_Object *win, GLData *gld)
{
Evas_Object *bg, *bx, *bt, *gl;
Ecore_Animator *ani;
bg = elm_bg_add(win);
elm_win_resize_object_add(win, bg);
evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(bg);
bx = elm_box_add(win);
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_win_resize_object_add(win, bx);
evas_object_show(bx);
//-//-//-// THIS IS WHERE GL INIT STUFF HAPPENS (ALA EGL)
//-//
// create a new glview object
gl = elm_glview_add(win);
gld->glapi = elm_glview_gl_api_get(gl);
evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
// mode is simply for supporting alpha, depth buffering, and stencil
// buffering.
elm_glview_mode_set(gl, ELM_GLVIEW_ALPHA | ELM_GLVIEW_DEPTH);
// resize policy tells glview what to do with the surface when it
// resizes. ELM_GLVIEW_RESIZE_POLICY_RECREATE will tell it to
// destroy the current surface and recreate it to the new size
elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
// render policy tells glview how it would like glview to render
// gl code. ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the gl
// calls called in the pixel_get callback, which only gets called
// if the object is visible, hence ON_DEMAND. ALWAYS mode renders
// it despite the visibility of the object.
elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
// initialize callback function gets registered here
elm_glview_init_func_set(gl, _init_gl);
// delete callback function gets registered here
elm_glview_del_func_set(gl, _del_gl);
elm_glview_resize_func_set(gl, _resize_gl);
elm_glview_render_func_set(gl, _draw_gl);
//-//
//-//-//-// END GL INIT BLOB
elm_box_pack_end(bx, gl);
evas_object_show(gl);
elm_object_focus_set(gl, EINA_TRUE);
// animating - just a demo. as long as you trigger an update on the image
// object via elm_glview_changed_set() it will be updated.
//
// NOTE: if you delete gl, this animator will keep running trying to access
// gl so you'd better delete this animator with ecore_animator_del().
ani = ecore_animator_add(_anim, gl);
evas_object_data_set(gl, "ani", ani);
evas_object_data_set(gl, "gld", gld);
evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, _del, gl);
// add an 'OK' button to end the program
bt = elm_button_add(win);
elm_object_text_set(bt, "OK");
evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
elm_box_pack_end(bx, bt);
evas_object_show(bt);
evas_object_smart_callback_add(bt, "clicked", _on_done, win);
evas_object_resize(win, 320, 480);
}
static bool app_create(void *data)
{
/* Hook to take necessary actions before main event loop starts
* Initialize UI resources and application's data
* If this function returns true, the main loop of application starts
* If this function returns false, the application is terminated. */
Evas_Object *gl;
appdata_s *ad = data;
if (!data)
return false;
/* Create the window */
ad->win = add_win(ad->name);
if (!ad->win)
return false;
create_indicator(ad);
evas_object_smart_callback_add(ad->win, "delete,request", win_delete_request_cb, NULL);
eext_object_event_callback_add(ad->win, EEXT_CALLBACK_BACK, win_back_cb, ad);
/* Create and initialize GLView */
gl = elm_glview_add(ad->conform);
ELEMENTARY_GLVIEW_GLOBAL_USE(gl);
evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
/* Request a surface with alpha and a depth buffer */
elm_glview_mode_set(gl, ELM_GLVIEW_DEPTH);
/* The resize policy tells GLView what to do with the surface when it
* resizes. ELM_GLVIEW_RESIZE_POLICY_RECREATE will tell it to
* destroy the current surface and recreate it to the new size.
*/
elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
/* The render policy sets how GLView should render GL code.
* ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the GL callback
* called only when the object is visible.
* ELM_GLVIEW_RENDER_POLICY_ALWAYS would cause the callback to be
* called even if the object were hidden.
*/
elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
/* The initialize callback function gets registered here */
elm_glview_init_func_set(gl, init_gl);
/* The delete callback function gets registered here */
elm_glview_del_func_set(gl, del_gl);
/* The resize callback function gets registered here */
elm_glview_resize_func_set(gl, resize_gl);
/* The render callback function gets registered here */
elm_glview_render_func_set(gl, draw_gl);
/* Add the GLView to the conformant and show it */
elm_object_content_set(ad->conform, gl);
evas_object_show(gl);
elm_object_focus_set(gl, EINA_TRUE);
/* This adds an animator so that the app will regularly
* trigger updates of the GLView using elm_glview_changed_set().
*
* NOTE: If you delete GL, this animator will keep running trying to access
* GL so this animator needs to be deleted with ecore_animator_del().
*/
ad->ani = ecore_animator_add(anim, gl);
evas_object_data_set(gl, "ad", ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, del_anim, gl);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_DOWN, mouse_down_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_UP, mouse_up_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_MOVE, mouse_move_cb, ad);
evas_object_show(ad->win);
/* Return true: the main loop will now start running */
return true;
}
static void
_create_view_layout(Evas_Object *parent, char *layout_file, char *index_style, char it_style[][20], Eina_Bool even_num)
{
Evas_Object *layout, *scroller, *box, *left_right_rect, *img, *page_layout, *index;
Elm_Object_Item *nf_it;
char img_path[PATH_MAX];
int i, max_items;
page_data *pd = (page_data *)calloc(1, sizeof(page_data));
/* Create Layout */
layout = elm_layout_add(parent);
elm_layout_file_set(layout, ELM_DEMO_EDJ, layout_file);
evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(layout);
evas_object_event_callback_add(layout, EVAS_CALLBACK_DEL, _layout_del_cb, pd);
pd->main_layout = layout;
/* Create Scroller */
scroller = elm_scroller_add(layout);
elm_scroller_loop_set(scroller, EINA_FALSE, EINA_FALSE);
evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
elm_scroller_page_scroll_limit_set(scroller, 1, 0);
elm_object_scroll_lock_y_set(scroller, EINA_TRUE);
elm_object_part_content_set(layout, "scroller", scroller);
evas_object_show(scroller);
evas_object_smart_callback_add(scroller, "scroll", _scroll, pd);
pd->scroller = scroller;
/* Create Box */
box = elm_box_add(scroller);
elm_box_horizontal_set(box, EINA_TRUE);
elm_object_content_set(scroller, box);
evas_object_show(box);
pd->box = box;
/* Create Rect object for page_layout center align in Box */
left_right_rect = evas_object_rectangle_add(evas_object_evas_get(box));
elm_box_pack_end(box, left_right_rect);
/* Create Pages */
if (even_num)
max_items = NUM_INDEX_CIRCLE_EVEN;
else
max_items = NUM_ITEMS;
for (i = 0; i < max_items; ++i)
{
page_layout = elm_layout_add(box);
pd->page_layout[i] = page_layout;
evas_object_size_hint_weight_set(page_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(page_layout, 0, EVAS_HINT_FILL);
elm_layout_theme_set(page_layout, "layout", "body_thumbnail", "default");
evas_object_show(page_layout);
img = elm_image_add(page_layout);
snprintf(img_path, sizeof(img_path), "%s/100_%d.jpg", ICON_DIR, (i % 6) + 1);
elm_image_file_set(img, img_path, NULL);
elm_object_part_content_set(page_layout, "elm.icon", img);
/* Make unselect state all of the pages except first one */
if (i)
elm_object_signal_emit(page_layout, "elm,state,thumbnail,unselect", "elm");
elm_box_pack_end(box, page_layout);
}
/*Add resize callback for get a actual size of layout and main layout */
evas_object_event_callback_add(pd->page_layout[0], EVAS_CALLBACK_RESIZE, _layout_resize_cb, pd);
elm_box_pack_end(box, left_right_rect);
pd->left_right_rect = left_right_rect;
/* Add animator for page transfer effect */
ecore_animator_add(animator_cb, pd);
/* Create Index */
index = elm_index_add(layout);
elm_object_style_set(index, index_style);
evas_object_size_hint_weight_set(index, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(index, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_index_horizontal_set(index, EINA_TRUE);
elm_index_autohide_disabled_set(index, EINA_TRUE);
elm_object_part_content_set(layout, "controller", index);
for (i = 0; i < max_items; ++i)
{
pd->it[i] = elm_index_item_append(index, NULL, NULL, (void *) i);
if (it_style)
elm_object_item_style_set(pd->it[i], it_style[i]);
}
pd->min_page = 0;
pd->max_page = max_items - 1;
elm_index_level_go(index, 0);
elm_index_item_selected_set(pd->it[0], EINA_TRUE);
pd->cur_page = 0;
pd->index = index;
pd->last_it = pd->it[0];
evas_object_event_callback_add(index, EVAS_CALLBACK_MOUSE_DOWN, _on_index_mouse_down_cb, pd);
evas_object_event_callback_add(index, EVAS_CALLBACK_MOUSE_MOVE, _on_index_mouse_move_cb, pd);
evas_object_event_callback_add(index, EVAS_CALLBACK_MOUSE_UP, _on_index_mouse_up_cb, pd);
nf_it = elm_naviframe_item_push(parent, NULL, NULL, NULL, layout, NULL);
elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
}
static bool app_create(void *data) {
/* Hook to take necessary actions before main event loop starts
* Initialize UI resources and application's data
* If this function returns true, the main loop of application starts
* If this function returns false, the application is terminated. */
Evas_Object *gl;
Application *ad = (Application *)data;
if (!data)
return false;
/* Create and initialize GLView */
elm_config_accel_preference_set("opengl");
/* Create the window */
ad->_win = add_win("cocos2d-x");
if (!ad->_win)
return false;
int rots[2];
rots[0] = ad->_orientation;
rots[1] = rots[0] + 180 % 360;
elm_win_wm_rotation_available_rotations_set(ad->_win, rots, 2);
ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _key_down_cb, ad);
ecore_event_handler_add(ECORE_EVENT_KEY_UP, _key_up_cb, ad);
gl = elm_glview_add(ad->_win);
elm_win_resize_object_add(ad->_win, gl);
ELEMENTARY_GLVIEW_GLOBAL_USE(gl);
evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
/* Create and initialize GLView */
ad->initGLContextAttrs();
auto attrs = GLView::getGLContextAttrs();
auto mode = get_glview_mode(attrs);
elm_glview_mode_set(gl, mode);
/* The resize policy tells GLView what to do with the surface when it
* resizes. ELM_GLVIEW_RESIZE_POLICY_RECREATE will tell it to
* destroy the current surface and recreate it to the new size.
*/
//elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
/* The render policy sets how GLView should render GL code.
* ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the GL callback
* called only when the object is visible.
* ELM_GLVIEW_RENDER_POLICY_ALWAYS would cause the callback to be
* called even if the object were hidden.
*/
elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
/* The initialize callback function gets registered here */
elm_glview_init_func_set(gl, init_gl);
/* The delete callback function gets registered here */
elm_glview_del_func_set(gl, del_gl);
/* The resize callback function gets registered here */
// Cocos2d-x doesn't support to change orientation from portrait to landscape.
// So comment next line.
// elm_glview_resize_func_set(gl, resize_gl);
/* The render callback function gets registered here */
elm_glview_render_func_set(gl, draw_gl);
/* Add the GLView to the box and show it */
evas_object_show(gl);
elm_object_focus_set(gl, EINA_TRUE);
/* This adds an animator so that the app will regularly
* trigger updates of the GLView using elm_glview_changed_set().
*
* NOTE: If you delete GL, this animator will keep running trying to access
* GL so this animator needs to be deleted with ecore_animator_del().
*/
ecore_animator_source_set(ECORE_ANIMATOR_SOURCE_TIMER);
ad->_ani = ecore_animator_add(anim, gl);
evas_object_data_set(gl, "ani", ad->_ani);
evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, del_anim, gl);
/* Add Mouse Event Callbacks */
evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_DOWN, touch_down_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_MOVE, touch_move_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_UP, touch_up_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MULTI_DOWN, touches_down_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MULTI_MOVE, touches_move_cb, ad);
evas_object_event_callback_add(gl, EVAS_CALLBACK_MULTI_UP, touches_up_cb, ad);
create_indicator(ad);
return true;
}
void GestureHandler::handleFlick(const IntSize& offset)
{
m_flickOffset = offset;
m_flickIndex = m_flickDuration = 1 / ecore_animator_frametime_get();
m_flickAnimator = ecore_animator_add(flickAnimatorCallback, this);
}
void GestureHandler::handlePanStarted(const IntPoint& point)
{
ASSERT(!m_panAnimator);
m_panAnimator = ecore_animator_add(panAnimatorCallback, this);
m_lastPoint = m_currentPoint = point;
}
if (_apply_delay) ecore_timer_del(_apply_delay);
if (_fade_animator) ecore_animator_del(_fade_animator);
_apply_delay = NULL;
_fade_animator = NULL;
_applying = EINA_FALSE;
_fade_obj = NULL;
}
static Eina_Bool
_cb_delay_timer(void *data EINA_UNUSED)
{
_apply_delay = NULL;
_target_from = 255;
_target_to = 0;
_start_time = ecore_loop_time_get();
_fade_animator = ecore_animator_add(_cb_fade_animator, NULL);
return EINA_FALSE;
}
static Eina_Bool
_cb_fade_animator(void *data EINA_UNUSED)
{
double t = ecore_loop_time_get() - _start_time;
int v;
t = t / 0.5;
if (t < 0.0) t = 0.0;
v = _target_from + ((_target_to - _target_from) * t);
if (t >= 1.0) v = _target_to;
evas_object_color_set(_fade_obj, 0, 0, 0, v);
if (v == _target_to)
void Animator::init()
{
m_Animator = ecore_animator_add( timer_func, this );
ecore_animator_freeze( m_Animator );
}
Evas_Object *
SampleView::CreateView(void *data) const {
appdata_s *ad = static_cast<appdata_s *>(data);
/* Create and initialize GLView */
Evas_Object *glview = elm_glview_version_add(ad->navi, EVAS_GL_GLES_3_X);
//Evas_Object* glview = elm_glview_add(ad->navi); //for GLES 2.0
ELEMENTARY_GLVIEW_GLOBAL_USE(glview);
evas_object_size_hint_align_set(glview, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(glview, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
/* Request a surface with alpha and a depth buffer */
elm_glview_mode_set(glview, ELM_GLVIEW_DEPTH);
/* The resize policy tells GLView what to do with the surface when it
* resizes. ELM_GLVIEW_RESIZE_POLICY_RECREATE will tell it to
* destroy the current surface and recreate it to the new size.
*/
elm_glview_resize_policy_set(glview, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
/* The render policy sets how GLView should render GL code.
* ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the GL callback
* called only when the obj is visible.
* ELM_GLVIEW_RENDER_POLICY_ALWAYS would cause the callback to be
* called even if the obj were hidden.
*/
elm_glview_render_policy_set(glview, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
/* The initialize callback function gets registered here */
elm_glview_init_func_set(glview, init_glview);
/* The delete callback function gets registered here */
elm_glview_del_func_set(glview, del_glview);
/* The resize callback function gets registered here */
elm_glview_resize_func_set(glview, resize_glview);
/* The render callback function gets registered here */
elm_glview_render_func_set(glview, draw_glview);
/* This adds an animator so that the app will regularly
* trigger updates of the GLView using elm_glview_changed_set().
*
* NOTE: If you delete GL, this animator will keep running trying to access
* GL so this animator needs to be deleted with ecore_animator_del().
*/
Ecore_Animator *ani = ecore_animator_add(anim_cb, glview);
evas_object_event_callback_add(glview, EVAS_CALLBACK_DEL, del_anim_cb, glview);
//
evas_object_event_callback_add(glview, EVAS_CALLBACK_MOUSE_DOWN, mouse_down_cb, ad);
evas_object_event_callback_add(glview, EVAS_CALLBACK_MOUSE_UP, mouse_up_cb, ad);
evas_object_event_callback_add(glview, EVAS_CALLBACK_MOUSE_MOVE, mouse_move_cb, ad);
evas_object_data_set(glview, "ad", ad);
evas_object_data_set(glview, "ani", ani);
evas_object_data_set(glview, "sv", this);
return glview;
}
int
main(int argc, char *argv[])
{
app_t app;
int i;
char *engine = "x11-16";
ecore_init();
ecore_app_args_set(argc, (const char **)argv);
ecore_evas_init();
edje_init();
edje_frametime_set(1.0 / 30.0);
memset(&app, 0, sizeof(app));
app.theme = THEME;
app.fs = 1;
app.total_ms = 1000;
app.fade_in = 1;
for (i=1; i < argc; i++)
if (strcmp (argv[i], "-fs") == 0)
ecore_evas_fullscreen_set(app.ee, 1);
else if (strncmp (argv[i], "-theme=", sizeof("-theme=") - 1) == 0)
app.theme = argv[i] + sizeof("-theme=") - 1;
else if (strncmp (argv[i], "-time=", sizeof("-time=") - 1) == 0)
app.total_ms = atoi(argv[i] + sizeof("-time=") - 1);
else if (strncmp (argv[i], "-engine=", sizeof("-engine=") - 1) == 0)
engine = argv[i] + sizeof("-engine=") - 1;
if (app.total_ms < 1)
app.total_ms = 1000;
app.ee = init_ecore_evas(engine);
if (!app.ee) {
fprintf(stderr, "Could not init engine '%s'.\n", engine);
return 1;
}
ecore_evas_data_set(app.ee, "app", &app);
ecore_evas_title_set(app.ee, TITLE);
ecore_evas_name_class_set(app.ee, WM_NAME, WM_CLASS);
ecore_evas_fullscreen_set(app.ee, app.fs);
fprintf(stderr, "time to fade: %dms\n", app.total_ms);
app.evas = ecore_evas_get(app.ee);
app.edje_main = edje_object_add(app.evas);
evas_data_attach_set(app.evas, &app);
if (!edje_object_file_set(app.edje_main, app.theme, THEME_GROUP)) {
fprintf(stderr, "Failed to load file \"%s\", part \"%s\".\n",
app.theme, THEME_GROUP);
return 1;
}
app.obj = edje_object_part_object_get(app.edje_main, "obj");
evas_object_move(app.edje_main, 0, 0);
evas_object_resize(app.edje_main, WIDTH, HEIGHT);
evas_object_show(app.edje_main);
ecore_evas_show(app.ee);
ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, app_signal_exit, NULL);
ecore_evas_callback_resize_set(app.ee, resize_cb);
evas_object_event_callback_add(app.edje_main, EVAS_CALLBACK_KEY_DOWN,
key_down, &app);
evas_object_focus_set(app.edje_main, 1);
gettimeofday(&app.start, NULL);
app.anim = ecore_animator_add(do_anim, &app);
ecore_main_loop_begin();
return 0;
}
EAPI void
ede_game_start(void)
{
Ede_Level *level;
int row = 0, col = 0;
D(" ");
level = ede_level_current_get();
ede_gui_level_selector_hide();
ede_gui_menu_hide();
ede_gui_level_init(level->rows, level->cols, level->towers);
// populate the checkboard with walls, start points and home
for (row = 0; row < level->rows; row++)
{
for (col = 0; col < level->cols; col++)
{
#if LOCAL_DEBUG
// DBG show col/row numbers
if (row == 0)
{
ede_gui_cell_overlay_add(OVERLAY_BORDER_RED, row, col);
ede_gui_cell_overlay_text_set(row, col, col, 1);
}
if (col == 0)
{
ede_gui_cell_overlay_add(OVERLAY_BORDER_RED, row, col);
ede_gui_cell_overlay_text_set(row, col, row, 2);
}
#endif
//~ printf("%d\n", level->cells[row][col]);
switch (cells[row][col])
{
case CELL_WALL:
ede_gui_cell_overlay_add(OVERLAY_IMAGE_WALL, row, col);
break;
case CELL_START0:case CELL_START1:case CELL_START2:case CELL_START3:
case CELL_START4:case CELL_START5:case CELL_START6:case CELL_START7:
case CELL_START8:case CELL_START9:
ede_gui_cell_overlay_add(OVERLAY_COLOR_RED, row, col);
ede_gui_cell_overlay_text_set(row, col, cells[row][col] - CELL_START0, 1);
break;
default:
break;
}
}
}
ede_gui_cell_overlay_add(OVERLAY_COLOR_GREEN, level->home_row, level->home_col);
_player_lives = level->lives;
_player_bucks = level->bucks;
_player_score = 0;
_play_time = 0.0;
ede_gui_lives_set(_player_lives);
ede_gui_bucks_set(_player_bucks);
ede_gui_score_set(_player_score);
ede_game_state_set(GAME_STATE_PLAYING);
ede_wave_start();
ecore_animator_frametime_set(1.0 / MAX_FPS);
if (!_animator)
_animator = ecore_animator_add(_game_loop, NULL);
}
