int main(void) { double done; eina_init(); ecore_init(); ecore_con_init(); eina_log_domain_level_set("ecore_con", EINA_LOG_LEVEL_ERR); eina_log_domain_level_set("eina", EINA_LOG_LEVEL_ERR); counter = eina_counter_new("client"); eina_counter_start(counter); done = ecore_time_get(); ecore_job_add(_spawn, NULL); /* set event handler for server connect */ ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, NULL); ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_del, NULL); /* start client */ ecore_main_loop_begin(); eina_counter_stop(counter, 1); printf("\nTime elapsed for %i connections: %f seconds\n%s", NUM_CLIENTS, ecore_time_get() - done, eina_counter_dump(counter)); return 0; }
static Eina_Bool _ecore_con_url_idler_handler(void *data) { double start; int done = 1, still_running; start = ecore_time_get(); while (curl_multi_perform(curlm, &still_running) == CURLM_CALL_MULTI_PERFORM) /* make this not more than a frametime to keep interactivity high */ if ((ecore_time_get() - start) > ecore_animator_frametime_get()) { done = 0; break; } _ecore_con_url_process_completed_jobs(NULL); if (done) { _ecore_con_url_restart_fd_handler(); _fd_idler_handler = NULL; if (!_url_con_list) ecore_timer_freeze(_curl_timeout); return data == (void*) 0xACE ? ECORE_CALLBACK_RENEW : ECORE_CALLBACK_CANCEL; } return ECORE_CALLBACK_RENEW; }
int _battery_openbsd_start(void) { int mib[] = {CTL_HW, HW_SENSORS, 0, 0, 0}; int devn; struct sensordev snsrdev; size_t sdlen = sizeof(struct sensordev); for (devn = 0;; devn++) { mib[2] = devn; if (sysctl(mib, 3, &snsrdev, &sdlen, NULL, 0) == -1) { if (errno == ENXIO) continue; if (errno == ENOENT) break; } if (!strcmp("acpibat0", snsrdev.xname)) { if (!(bat = E_NEW(Battery, 1))) return 0; bat->udi = eina_stringshare_add("acpibat0"), bat->mib = malloc(sizeof(int) * 5); if (!bat->mib) return 0; bat->mib[0] = mib[0]; bat->mib[1] = mib[1]; bat->mib[2] = mib[2]; bat->technology = eina_stringshare_add("Unknow"); bat->model = eina_stringshare_add("Unknow"); bat->vendor = eina_stringshare_add("Unknow"); bat->last_update = ecore_time_get(); bat->poll = ecore_poller_add(ECORE_POLLER_CORE, battery_config->poll_interval, _battery_openbsd_battery_update_poll, NULL); device_batteries = eina_list_append(device_batteries, bat); } else if (!strcmp("acpiac0", snsrdev.xname)) { if (!(ac = E_NEW(Ac_Adapter, 1))) return 0; ac->udi = eina_stringshare_add("acpiac0"); ac->mib = malloc(sizeof(int) * 5); if (!ac->mib) return 0; ac->mib[0] = mib[0]; ac->mib[1] = mib[1]; ac->mib[2] = mib[2]; device_ac_adapters = eina_list_append(device_ac_adapters, ac); } } _battery_openbsd_battery_update(); init_time = ecore_time_get(); return 1; }
int main(void) { double start; Eina_Hash *headers; eina_init(); ecore_init(); ecore_file_init(); if (ecore_file_exists(DST)) ecore_file_unlink(DST); start = ecore_time_get(); if (ecore_file_download(URL, DST, completion_cb, progress_cb, NULL, NULL)) { printf("Download started successfully:\n URL: %s\n DEST: %s\n", URL, DST); ecore_main_loop_begin(); printf("\nTime elapsed: %f seconds\n", ecore_time_get() - start); printf("Downloaded %lld bytes\n", ecore_file_size(DST)); } else { printf("Error, can't start download\n"); goto done; } headers = eina_hash_string_small_new(NULL); eina_hash_add(headers, "Content-type", "application/x-gzip"); if (ecore_file_download_full(URL, DST_MIME, completion_cb, progress_cb, NULL, NULL, headers)) { printf("Download started successfully:\n URL: %s\n DEST: %s\n", URL, DST_MIME); ecore_main_loop_begin(); printf("\nTime elapsed: %f seconds\n", ecore_time_get() - start); printf("Downloaded %lld bytes\n", ecore_file_size(DST)); } else { printf("Error, can't start download\n"); goto done; } done: if (headers) eina_hash_free(headers); ecore_file_shutdown(); ecore_shutdown(); eina_shutdown(); return 0; }
void XmasWidget::_Animator() { double d; for (uint i = 0;i < flakes.size();i++) { Flake *flake = flakes[i]; Evas_Coord _y; d = ecore_time_get() - flake->getStart(); _y = 30 * d * flake->getSpeed(); if (_y > cliph) flake->setStart(ecore_time_get() + (double)(random() % 100) / (double)100); flake->Move(flake->getX(), _y + clipy); } }
/** * Resumes a frozen (paused) timer. * * @param timer The timer to be resumed. * * The timer will be resumed from its previous relative position in time. That * means, if it had X seconds remaining until expire when it was paused, it will * be started now with those same X seconds remaining to expire again. But * notice that the interval time won't be touched by this call or by * ecore_timer_freeze(). * * @see ecore_timer_freeze() */ EAPI void ecore_timer_thaw(Ecore_Timer *timer) { double now; _ecore_lock(); if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) { ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER, "ecore_timer_thaw"); goto unlock; } /* Timer not frozen */ if (!timer->frozen) goto unlock; suspended = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer)); now = ecore_time_get(); _ecore_timer_set(timer, timer->pending + now, timer->in, timer->func, timer->data); unlock: _ecore_unlock(); }
/** * Get the pending time regarding a timer. * * @param timer The timer to learn from. * @ingroup Ecore_Time_Group */ EAPI double ecore_timer_pending_get(Ecore_Timer *timer) { double now; double ret = 0.0; _ecore_lock(); if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) { ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER, "ecore_timer_pending_get"); goto unlock; } now = ecore_time_get(); if (timer->frozen) ret = timer->pending; else ret = timer->at - now; unlock: _ecore_unlock(); return ret; }
/** * Creates a timer to call the given function in the given period of time. * @param in The interval in seconds. * @param func The given function. If @p func returns 1, the timer is * rescheduled for the next interval @p in. * @param data Data to pass to @p func when it is called. * @return A timer object on success. @c NULL on failure. * * This function adds a timer and returns its handle on success and NULL on * failure. The function @p func will be called every @p in seconds. The * function will be passed the @p data pointer as its parameter. * * When the timer @p func is called, it must return a value of either 1 * (or ECORE_CALLBACK_RENEW) or 0 (or ECORE_CALLBACK_CANCEL). * If it returns 1, it will be called again at the next tick, or if it returns * 0 it will be deleted automatically making any references/handles for it * invalid. */ EAPI Ecore_Timer * ecore_timer_add(double in, Ecore_Task_Cb func, const void *data) { double now; Ecore_Timer *timer = NULL; _ecore_lock(); if (!func) goto unlock; if (in < 0.0) in = 0.0; timer = ecore_timer_calloc(1); if (!timer) goto unlock; ECORE_MAGIC_SET(timer, ECORE_MAGIC_TIMER); now = ecore_time_get(); #ifdef WANT_ECORE_TIMER_DUMP timer->timer_bt_num = backtrace((void **)(timer->timer_bt), ECORE_TIMER_DEBUG_BT_NUM); #endif _ecore_timer_set(timer, now + in, in, func, (void *)data); unlock: _ecore_unlock(); return timer; }
EAPI void ecore_timer_freeze(Ecore_Timer *timer) { double now; if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) { ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER, "ecore_timer_freeze"); return ; } /* Timer already frozen */ if (timer->frozen) return ; timers = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer)); suspended = (Ecore_Timer *) eina_inlist_prepend(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer)); now = ecore_time_get(); timer->pending = timer->at - now; timer->at = 0.0; timer->frozen = 1; }
/*** internal plugin functions ***/ static int _container_scroll_timer(void *data) { Container *cont = data; double dt, dx, size, pad, max_scroll; dt = ecore_time_get() - cont->scroll.start_time; dx = 10 * (1 - exp(-dt)); cont->scroll.offset += dx * cont->scroll.velocity; size = cont->direction ? cont->h : cont->w; pad = cont->direction ? cont->padding.t + cont->padding.b : cont->padding.l + cont->padding.r; max_scroll = size - cont->length - pad; if (cont->scroll.offset < max_scroll) { cont->scroll.offset = max_scroll; _default_scroll_stop(cont); } else if (cont->scroll.offset > 0) { cont->scroll.offset = 0; _default_scroll_stop(cont); } _default_layout(cont); return 1; }
/* 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) { #ifdef HAVE_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; CRIT("Cannot get a valid clock_gettime() clock id! " "Fallback to unix time."); } #else # ifndef HAVE_EVIL # warning "Your platform isn't supported yet" CRIT("Platform does not support clock_gettime. " "Fallback to unix time."); # endif #endif _ecore_time_loop_time = ecore_time_get(); }
/** * @internal * @param w: The widget to work with * @ev_data: The Ewl_Event_Mouse_Down data * @param data: The scrollport * @return Returns no value * @brief The mouse down function for kinetic scrolling */ static void ewl_scrollport_kinetic_cb_mouse_down_embedded(Ewl_Widget *w, void *ev, void *data) { Ewl_Scrollport *s; Ewl_Event_Mouse *md; Ewl_Scrollport_Kinetic_Info_Embedded *info; DENTER_FUNCTION(DLEVEL_STABLE); DCHECK_PARAM_PTR(ev); DCHECK_PARAM_PTR(data); DCHECK_TYPE(w, EWL_WIDGET_TYPE); s = EWL_SCROLLPORT(data); md = EWL_EVENT_MOUSE(ev); info = s->kinfo->extra; s->kinfo->clicked = !!TRUE; s->kinfo->active = !!FALSE; memset(&(info->back[0]), 0, sizeof(info->back[0]) * HIST_NUM); info->back[0].x = md->x; info->back[0].y = md->y; info->back[0].time = ecore_time_get(); info->xs = md->x; info->ys = md->y; DLEAVE_FUNCTION(DLEVEL_STABLE); }
int main(int argc, char **argv) { double interval = 0.3; // tick each 0.3 seconds Ecore_Poller *poller1, *poller2; char *str1 = "poller1"; char *str2 = "poller2"; if (!ecore_init()) { printf("ERROR: Cannot init Ecore!\n"); return -1; } _initial_time = ecore_time_get(); ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval); poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1); poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2); ecore_main_loop_begin(); printf("changing poller2 interval to 16\n"); ecore_poller_poller_interval_set(poller2, 16); ecore_main_loop_begin(); ecore_poller_del(poller1); ecore_poller_del(poller2); ecore_shutdown(); }
Eina_List * eio_pack_send(Ecore_Thread *thread, Eina_List *pack, double *start) { double current; current = ecore_time_get(); if (current - *start > EIO_PACKED_TIME) { *start = current; ecore_thread_feedback(thread, pack); return NULL; } if (memory_pool_limit > 0 && memory_pool_usage > memory_pool_limit) { eina_lock_take(&(memory_pool_mutex)); memory_pool_suspended = EINA_TRUE; eina_condition_wait(&(memory_pool_cond)); memory_pool_suspended = EINA_FALSE; eina_lock_release(&(memory_pool_mutex)); } return pack; }
static void _eio_file_heavy(void *data, Ecore_Thread *thread) { Eio_File_Char_Ls *async = data; Eina_Iterator *ls; const char *file; Eina_List *pack = NULL; double start; ls = eina_file_ls(async->ls.directory); if (!ls) { eio_file_thread_error(&async->ls.common, thread); return; } eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls)); start = ecore_time_get(); EINA_ITERATOR_FOREACH(ls, file) { Eina_Bool filter = EINA_TRUE; if (async->filter_cb) { filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, file); } if (filter) { Eio_File_Char *send_fc; send_fc = eio_char_malloc(); if (!send_fc) goto on_error; send_fc->filename = file; send_fc->associated = async->ls.common.worker.associated; async->ls.common.worker.associated = NULL; pack = eina_list_append(pack, send_fc); } else { on_error: eina_stringshare_del(file); if (async->ls.common.worker.associated) { eina_hash_free(async->ls.common.worker.associated); async->ls.common.worker.associated = NULL; } } pack = eio_pack_send(thread, pack, &start); if (ecore_thread_check(thread)) break; }
int ef_mime_cb_get(void) { const char *mime = NULL, *icon; int misses = 0, i = 0; struct { char *file; char *mime; } files[] = { {"test_type.desktop", "application/x-desktop"}, {"entry.png", "image/png"}, {"entry", "image/png"}, {"sub", "inode/directory"}, { } }; double start; if (!efreet_mime_init()) { printf("Could not init efreet\n"); return 1; } for (i = 0; files[i].file; ++i) { mime = efreet_mime_type_get(ef_test_path_get(files[i].file)); if (!mime) { printf("Got %s as null instead of %s\n", files[i].file, files[i].mime); misses ++; } else if (strcmp(mime, files[i].mime)) { printf("Got %s as %s instead of %s\n", files[i].file, mime, files[i].mime); misses ++; } start = ecore_time_get(); icon = efreet_mime_type_icon_get(files[i].mime, THEME, SIZE); printf("mime icon: %s %s %f\n", files[i].mime, icon, ecore_time_get() - start); } efreet_mime_shutdown(); return !misses; }
static void _ecore_poller_next_tick_eval(void) { int i; double interval; min_interval = -1; for (i = 0; i < 15; i++) { if (pollers[i]) { min_interval = i; break; } } if (min_interval < 0) { /* no pollers */ if (timer) { ecore_timer_del(timer); timer = NULL; } return; } interval_incr = (1 << min_interval); interval = interval_incr * poll_interval; /* we are at the tick callback - so no need to do inter-tick adjustments * so we can fasttrack this as t -= last_tick in theory is 0.0 (though * in practice it will be a very very very small value. also the tick * callback will adjust the timer interval at the end anyway */ if (at_tick) { if (!timer) timer = ecore_timer_add(interval, _ecore_poller_cb_timer, NULL); } else { double t; if (!timer) timer = ecore_timer_add(interval, _ecore_poller_cb_timer, NULL); else { t = ecore_time_get(); if (interval != poll_cur_interval) { t -= last_tick; /* time since we last ticked */ /* delete the timer and reset it to tick off in the new * time interval. at the tick this will be adjusted */ ecore_timer_del(timer); timer = ecore_timer_add(interval - t, _ecore_poller_cb_timer, NULL); } } } poll_cur_interval = interval; }
static int ecore_idle(void *data) { static double last = 0; static int cnt = 0; cnt += fpsflag; if (cnt == 100) { cnt = 0; printf("%f\n", 1 / ((ecore_time_get() - last) / 100)); last = ecore_time_get(); } gui_apply(); gra_apply(); return 1; }
static Eina_Bool _poller_print_cb(void *data) { char *str = data; printf("Ecore Poller '%s' callback called after %0.3f seconds.\n", str, ecore_time_get() - _initial_time); return ECORE_CALLBACK_RENEW; }
static void _load_done_cb(void *data, Enlil_Load *load, int nb_albums __UNUSED__, int nb_photos __UNUSED__) { Enlil_Library *library = (Enlil_Library *)data; enlil_load_free(&load); t = ecore_time_get(); double _time = t - t0; LOG_ERR("Load Time: %f sec)", _time); t0_sync = ecore_time_get(); Enlil_Sync *_sync = enlil_library_sync_get(library); enlil_sync_job_all_add(_sync); }
void EventSenderProxy::mouseUp(unsigned button, WKEventModifiers wkModifiers) { sendOrQueueEvent(WTREvent(WTREventTypeMouseUp, 0, wkModifiers, evasMouseButton(button))); if (m_mouseButton == button) m_mouseButton = kWKEventMouseButtonNoButton; m_clickPosition = m_position; m_clickTime = ecore_time_get(); }
static double _elitaire_card_job_frametime_get(Elitaire_Card_Job * job) { double ft; if (job->t == 0.0) { Elitaire_Card * ecard; ecard = (Elitaire_Card *) evas_object_smart_data_get(job->card); ft = 1.0 / ecard->eli->frame_rate; job->t = ecore_time_get(); } else { double nt; nt = ecore_time_get(); ft = nt - job->t; job->t = nt; } return ft; }
int _battery_fso_start(void) { conn = e_dbus_bus_get(DBUS_BUS_SYSTEM); if (!conn) return 0; /* Initiate the battery gadget */ Battery *bat; const char *udi = "FSO"; bat = _battery_battery_find( udi ); if (!bat) { bat = E_NEW(Battery, 1); if (!bat) return 0; bat->udi = eina_stringshare_add(udi); device_batteries = eina_list_append(device_batteries, bat); } battery = bat; /* Get initial status */ _battery_fso_get_capacity( bat ); _battery_fso_get_powerstatus( bat ); /* Add signal listeners for PowerSupply.Capacity and PowerSupply.PowerStatus */ if( conn ) { nameowner_handler = e_dbus_signal_handler_add(conn, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "NameOwnerChanged", _battery_fso_on_nameowner_change, bat); capacity_handler = e_dbus_signal_handler_add( conn, "org.freesmartphone.odeviced", "/org/freesmartphone/Device/PowerSupply", "org.freesmartphone.Device.PowerSupply", "Capacity", _battery_fso_on_capacity_change, bat ); powerstatus_handler = e_dbus_signal_handler_add( conn, "org.freesmartphone.odeviced", "/org/freesmartphone/Device/PowerSupply", "org.freesmartphone.Device.PowerSupply", "PowerStatus", _battery_fso_on_powerstatus_change, bat ); } init_time = ecore_time_get(); return 1; }
int _ex_file_download_progress_cb(void *data, const char *file, long int dltotal, long int dlnow, long int ultotal, long int ulnow) { double fraction; char text[42]; static long int last; static double t_last; long int diff; double t_diff; double kbytes; static double total_kbytes; if (dlnow == 0 || dltotal == 0) return 0; if (!total_kbytes) total_kbytes = (double) ((((double)dltotal) / 1024)); if (last) { diff = dlnow - last; t_diff = ecore_time_get() - t_last; kbytes = (double) ((((double) diff) / 1024)); fraction = (double) ((double) dlnow) / ((double) dltotal); etk_progress_bar_fraction_set(ETK_PROGRESS_BAR(progressbar), fraction); snprintf(text, sizeof(text), "%d%% done at %.0f kb/s (%.0f of %.0f kb)", (int) (fraction * 100.0), kbytes / t_diff, kbytes, total_kbytes); etk_progress_bar_text_set(ETK_PROGRESS_BAR(progressbar), text); } t_last = ecore_time_get(); last = dlnow; return 0; }
bool XmasWidget::LoadWidget(std::string, double _x, double _y, std::string _id) { std::string witem = "calaos/widget/xmas"; if (!LoadEdje(witem)) { return false; } setLayer(500); EdjeObject::Show(); clip = evas_object_rectangle_add(evas); evas_object_show(clip); edje_object_part_swallow(edje, "widget.swallow", clip); Resize(1024, 768); //create some flakes for (int i = 0;i < MAX_FLAKE;i++) { std::string type; if (i < MAX_FLAKE / 3) type = "flake_small"; else if (i >= MAX_FLAKE / 3 && i < (MAX_FLAKE / 3) * 2) type = "flake_medium"; else type = "flake_large"; EdjeObject *o = new EdjeObject(theme, evas); if (!o->LoadEdje("calaos/widget/xmas/" + type)) cError() << "Error loading edje group calaos/widget/xmas/" + type; o->setLayer(500); evas_object_clip_set(o->getEvasObject(), clip); Flake *flake = new Flake(o); int tx = random() % clipw; int ty = random() % cliph; flake->Move(tx + clipx, ty + clipy); flake->Show(); flake->setStart(ecore_time_get() + (double)(random() % (flake->getHeight() * 10)) / (double)flake->getHeight()); if (type == "flake_small") flake->setSpeed(1); if (type == "flake_medium") flake->setSpeed(2); if (type == "flake_large") flake->setSpeed(3); flakes.push_back(flake); } return true; }
static void _timer_constructor(Eo *obj, void *_pd, va_list *list) { double in = va_arg(*list, double); Ecore_Task_Cb func = va_arg(*list, Ecore_Task_Cb); const void *data = va_arg(*list, const void *); double now; _ecore_lock(); now = ecore_time_get(); Ecore_Timer_Private_Data *timer = _pd; _ecore_timer_add(obj, timer, now, in, func, data); _ecore_unlock(); }
void GestureHandler::handlePan(const IntPoint& point) { m_currentPoint = point; m_isCurrentPointUpdated = true; // Save current point to use to calculate offset of flick. HistoryItem item = { m_currentPoint, ecore_time_get() }; if (m_history.size() < m_history.capacity()) m_history.uncheckedAppend(item); else { m_history[m_oldestHistoryItemIndex++] = item; if (m_oldestHistoryItemIndex == m_history.capacity()) m_oldestHistoryItemIndex = 0; } }
/** * Creates a timer to call the given function in the given period of time. * @param in The interval in seconds. * @param func The given function. If @p func returns 1, the timer is * rescheduled for the next interval @p in. * @param data Data to pass to @p func when it is called. * @return A timer object on success. @c NULL on failure. * * This function adds a timer and returns its handle on success and NULL on * failure. The function @p func will be called every @p in seconds. The * function will be passed the @p data pointer as its parameter. * * When the timer @p func is called, it must return a value of either 1 * (or ECORE_CALLBACK_RENEW) or 0 (or ECORE_CALLBACK_CANCEL). * If it returns 1, it will be called again at the next tick, or if it returns * 0 it will be deleted automatically making any references/handles for it * invalid. */ EAPI Ecore_Timer * ecore_timer_add(double in, Ecore_Task_Cb func, const void *data) { double now; Ecore_Timer *timer; if (!func) return NULL; if (in < 0.0) in = 0.0; timer = calloc(1, sizeof(Ecore_Timer)); if (!timer) return NULL; ECORE_MAGIC_SET(timer, ECORE_MAGIC_TIMER); now = ecore_time_get(); _ecore_timer_set(timer, now + in, in, func, (void *)data); return timer; }
/* 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(); }
int main(int argc, char **argv) { double interval = 0.3; // tick each 0.3 seconds Ecore_Poller *poller1, *poller2, *poller3; char *str1 = "poller1"; char *str2 = "poller2"; char *str3 = "poller3"; if (!ecore_init()) { printf("ERROR: Cannot init Ecore!\n"); return -1; } _initial_time = ecore_time_get(); ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval); // poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1); // poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2); // poller3 = ecore_poller_add(ECORE_POLLER_CORE, 30, _poller_quit_cb, str3); poller1 = eo_add_custom(ECORE_POLLER_CLASS, NULL, ecore_poller_constructor(ECORE_POLLER_CORE, 4, _poller_print_cb, str1)); poller2 = eo_add_custom(ECORE_POLLER_CLASS, NULL, ecore_poller_constructor(ECORE_POLLER_CORE, 8, _poller_print_cb, str2)); poller3 = eo_add_custom(ECORE_POLLER_CLASS, NULL, ecore_poller_constructor(ECORE_POLLER_CORE, 20, _poller_quit_cb, str3)); ecore_main_loop_begin(); printf("changing poller2 interval to 16\n"); // ecore_poller_poller_interval_set(poller2, 16); eo_do(poller2, ecore_poller_interval_set(16, NULL)); ecore_main_loop_begin(); eo_unref(poller1); eo_unref(poller2); eo_unref(poller3); // ecore_poller_del(poller1); // ecore_poller_del(poller2); // ecore_poller_del(poller3); ecore_shutdown(); }