From 46d4358209ca9e74d77b1580525e309427636411 Mon Sep 17 00:00:00 2001 From: Vincent Torri Date: Mon, 3 Dec 2012 19:36:16 +0000 Subject: [PATCH] Ecore: add examples SVN revision: 80097 --- configure.ac | 1 + src/examples/Makefile.am | 2 + src/examples/ecore/Makefile.am | 186 ++++++ src/examples/ecore/ecore_animator_example.c | 117 ++++ src/examples/ecore/ecore_client_bench.c | 79 +++ src/examples/ecore/ecore_con_client_example.c | 92 +++ .../ecore/ecore_con_client_simple_example.c | 126 ++++ src/examples/ecore/ecore_con_lookup_example.c | 40 ++ src/examples/ecore/ecore_con_server_example.c | 81 +++ .../ecore/ecore_con_server_http_example.c | 136 ++++ .../ecore/ecore_con_server_simple_example.c | 133 ++++ .../ecore/ecore_con_url_cookies_example.c | 123 ++++ .../ecore/ecore_con_url_download_example.c | 115 ++++ .../ecore/ecore_con_url_headers_example.c | 106 ++++ .../ecore/ecore_evas_basics_example.c | 89 +++ .../ecore/ecore_evas_buffer_example_01.c | 121 ++++ .../ecore/ecore_evas_buffer_example_02.c | 126 ++++ src/examples/ecore/ecore_evas_callbacks.c | 128 ++++ src/examples/ecore/ecore_evas_ews_example.c | 269 ++++++++ .../ecore/ecore_evas_object_example.c | 53 ++ .../ecore/ecore_evas_window_sizes_example.c | 204 ++++++ src/examples/ecore/ecore_event_example_01.c | 26 + src/examples/ecore/ecore_event_example_02.c | 89 +++ src/examples/ecore/ecore_exe_example.c | 100 +++ src/examples/ecore/ecore_exe_example_child.c | 57 ++ src/examples/ecore/ecore_fd_handler_example.c | 89 +++ .../ecore/ecore_fd_handler_gnutls_example.c | 203 ++++++ .../ecore/ecore_file_download_example.c | 86 +++ src/examples/ecore/ecore_idler_example.c | 117 ++++ src/examples/ecore/ecore_imf_example.c | 588 ++++++++++++++++++ src/examples/ecore/ecore_job_example.c | 50 ++ .../ecore/ecore_pipe_gstreamer_example.c | 190 ++++++ .../ecore/ecore_pipe_simple_example.c | 67 ++ src/examples/ecore/ecore_poller_example.c | 72 +++ src/examples/ecore/ecore_server_bench.c | 63 ++ src/examples/ecore/ecore_thread_example.c | 397 ++++++++++++ .../ecore/ecore_time_functions_example.c | 34 + src/examples/ecore/ecore_timer_example.c | 187 ++++++ .../examples => src/examples/ecore}/red.png | Bin 39 files changed, 4742 insertions(+) create mode 100644 src/examples/ecore/Makefile.am create mode 100644 src/examples/ecore/ecore_animator_example.c create mode 100644 src/examples/ecore/ecore_client_bench.c create mode 100644 src/examples/ecore/ecore_con_client_example.c create mode 100644 src/examples/ecore/ecore_con_client_simple_example.c create mode 100644 src/examples/ecore/ecore_con_lookup_example.c create mode 100644 src/examples/ecore/ecore_con_server_example.c create mode 100644 src/examples/ecore/ecore_con_server_http_example.c create mode 100644 src/examples/ecore/ecore_con_server_simple_example.c create mode 100644 src/examples/ecore/ecore_con_url_cookies_example.c create mode 100644 src/examples/ecore/ecore_con_url_download_example.c create mode 100644 src/examples/ecore/ecore_con_url_headers_example.c create mode 100644 src/examples/ecore/ecore_evas_basics_example.c create mode 100644 src/examples/ecore/ecore_evas_buffer_example_01.c create mode 100644 src/examples/ecore/ecore_evas_buffer_example_02.c create mode 100644 src/examples/ecore/ecore_evas_callbacks.c create mode 100644 src/examples/ecore/ecore_evas_ews_example.c create mode 100644 src/examples/ecore/ecore_evas_object_example.c create mode 100644 src/examples/ecore/ecore_evas_window_sizes_example.c create mode 100644 src/examples/ecore/ecore_event_example_01.c create mode 100644 src/examples/ecore/ecore_event_example_02.c create mode 100644 src/examples/ecore/ecore_exe_example.c create mode 100644 src/examples/ecore/ecore_exe_example_child.c create mode 100644 src/examples/ecore/ecore_fd_handler_example.c create mode 100644 src/examples/ecore/ecore_fd_handler_gnutls_example.c create mode 100644 src/examples/ecore/ecore_file_download_example.c create mode 100644 src/examples/ecore/ecore_idler_example.c create mode 100644 src/examples/ecore/ecore_imf_example.c create mode 100644 src/examples/ecore/ecore_job_example.c create mode 100644 src/examples/ecore/ecore_pipe_gstreamer_example.c create mode 100644 src/examples/ecore/ecore_pipe_simple_example.c create mode 100644 src/examples/ecore/ecore_poller_example.c create mode 100644 src/examples/ecore/ecore_server_bench.c create mode 100644 src/examples/ecore/ecore_thread_example.c create mode 100644 src/examples/ecore/ecore_time_functions_example.c create mode 100644 src/examples/ecore/ecore_timer_example.c rename {legacy/edje/src/examples => src/examples/ecore}/red.png (100%) diff --git a/configure.ac b/configure.ac index 73e4cc31bc..6186d7bd5a 100644 --- a/configure.ac +++ b/configure.ac @@ -4063,6 +4063,7 @@ src/examples/eina/Makefile src/examples/eet/Makefile src/examples/eo/Makefile src/examples/evas/Makefile +src/examples/ecore/Makefile src/lib/eina/eina_config.h spec/efl.spec pc/evil.pc diff --git a/src/examples/Makefile.am b/src/examples/Makefile.am index 831c727267..34e9f5154f 100644 --- a/src/examples/Makefile.am +++ b/src/examples/Makefile.am @@ -7,9 +7,11 @@ examples: @$(MAKE) $(AM_MAKEFLAGS) -C eo examples @$(MAKE) $(AM_MAKEFLAGS) -C eet examples @$(MAKE) $(AM_MAKEFLAGS) -C evas examples + @$(MAKE) $(AM_MAKEFLAGS) -C ecore examples install-examples: @$(MAKE) $(AM_MAKEFLAGS) -C eina install-examples @$(MAKE) $(AM_MAKEFLAGS) -C eo install-examples @$(MAKE) $(AM_MAKEFLAGS) -C eet install-examples @$(MAKE) $(AM_MAKEFLAGS) -C evas install-examples + @$(MAKE) $(AM_MAKEFLAGS) -C ecore install-examples diff --git a/src/examples/ecore/Makefile.am b/src/examples/ecore/Makefile.am new file mode 100644 index 0000000000..94ffd4ba4d --- /dev/null +++ b/src/examples/ecore/Makefile.am @@ -0,0 +1,186 @@ +MAINTAINERCLEANFILES = Makefile.in + +AM_CPPFLAGS = \ +-I$(top_srcdir)/src/lib/eina \ +-I$(top_srcdir)/src/lib/eo \ +-I$(top_srcdir)/src/lib/evas \ +-I$(top_srcdir)/src/lib/ecore \ +-I$(top_srcdir)/src/lib/ecore_input \ +-I$(top_srcdir)/src/lib/ecore_con \ +-I$(top_srcdir)/src/lib/ecore_evas \ +-I$(top_builddir)/src/lib/eina \ +-I$(top_builddir)/src/lib/eo \ +-I$(top_builddir)/src/lib/evas \ +-I$(top_builddir)/src/lib/ecore \ +-I$(top_builddir)/src/lib/ecore_input \ +-I$(top_builddir)/src/lib/ecore_con \ +-I$(top_builddir)/src/lib/ecore_evas \ +-DPACKAGE_EXAMPLES_DIR=\"$(datadir)/ecore/examples\" \ +@ECORE_CFLAGS@ + +EXTRA_PROGRAMS = \ +ecore_animator_example \ +ecore_client_bench \ +ecore_con_client_simple_example \ +ecore_con_lookup_example \ +ecore_con_server_http_example \ +ecore_con_server_simple_example \ +ecore_con_url_cookies_example \ +ecore_con_url_download_example \ +ecore_con_url_headers_example \ +ecore_evas_basics_example \ +ecore_evas_buffer_example_01 \ +ecore_evas_buffer_example_02 \ +ecore_evas_callbacks \ +ecore_evas_ews_example \ +ecore_evas_object_example \ +ecore_evas_window_sizes_example \ +ecore_event_example_01 \ +ecore_event_example_02 \ +ecore_exe_example \ +ecore_exe_example_child \ +ecore_fd_handler_example \ +ecore_idler_example \ +ecore_job_example \ +ecore_pipe_simple_example \ +ecore_poller_example \ +ecore_server_bench \ +ecore_thread_example \ +ecore_time_functions_example \ +ecore_timer_example + +ecore_animator_example_SOURCES = ecore_animator_example.c +ecore_animator_example_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_client_bench_SOURCES = ecore_client_bench.c +ecore_client_bench_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_client_simple_example_SOURCES = ecore_con_client_simple_example.c +ecore_con_client_simple_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_lookup_example_SOURCES = ecore_con_lookup_example.c +ecore_con_lookup_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_server_http_example_SOURCES = ecore_con_server_http_example.c +ecore_con_server_http_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_server_simple_example_SOURCES = ecore_con_server_simple_example.c +ecore_con_server_simple_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_url_cookies_example_SOURCES = ecore_con_url_cookies_example.c +ecore_con_url_cookies_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_url_download_example_SOURCES = ecore_con_url_download_example.c +ecore_con_url_download_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_con_url_headers_example_SOURCES = ecore_con_url_headers_example.c +ecore_con_url_headers_example_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_basics_example_SOURCES = ecore_evas_basics_example.c +ecore_evas_basics_example_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_buffer_example_01_SOURCES = ecore_evas_buffer_example_01.c +ecore_evas_buffer_example_01_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_buffer_example_02_SOURCES = ecore_evas_buffer_example_02.c +ecore_evas_buffer_example_02_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_callbacks_SOURCES = ecore_evas_callbacks.c +ecore_evas_callbacks_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_ews_example_SOURCES = ecore_evas_ews_example.c +ecore_evas_ews_example_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_object_example_SOURCES = ecore_evas_object_example.c +ecore_evas_object_example_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_evas_window_sizes_example_SOURCES = ecore_evas_window_sizes_example.c +ecore_evas_window_sizes_example_LDADD = $(top_builddir)/src/lib/ecore_evas/libecore_evas.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_event_example_01_SOURCES = ecore_event_example_01.c +ecore_event_example_01_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_event_example_02_SOURCES = ecore_event_example_02.c +ecore_event_example_02_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_exe_example_SOURCES = ecore_exe_example.c +ecore_exe_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_exe_example_child_SOURCES = ecore_exe_example_child.c +ecore_exe_example_child_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_fd_handler_example_SOURCES = ecore_fd_handler_example.c +ecore_fd_handler_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_idler_example_SOURCES = ecore_idler_example.c +ecore_idler_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_job_example_SOURCES = ecore_job_example.c +ecore_job_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_pipe_simple_example_SOURCES = ecore_pipe_simple_example.c +ecore_pipe_simple_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_poller_example_SOURCES = ecore_poller_example.c +ecore_poller_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_server_bench_SOURCES = ecore_server_bench.c +ecore_server_bench_LDADD = $(top_builddir)/src/lib/ecore_con/libecore_con.la $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_thread_example_SOURCES = ecore_thread_example.c +ecore_thread_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_time_functions_example_SOURCES = ecore_time_functions_example.c +ecore_time_functions_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +ecore_timer_example_SOURCES = ecore_timer_example.c +ecore_timer_example_LDADD = $(top_builddir)/src/lib/ecore/libecore.la @ECORE_LIBS@ + +SRCS = \ +ecore_animator_example \ +ecore_client_bench \ +ecore_con_client_simple_example \ +ecore_con_lookup_example \ +ecore_con_server_http_example \ +ecore_con_server_simple_example \ +ecore_con_url_cookies_example \ +ecore_con_url_download_example \ +ecore_con_url_headers_example \ +ecore_evas_basics_example \ +ecore_evas_buffer_example_01 \ +ecore_evas_buffer_example_02 \ +ecore_evas_callbacks \ +ecore_evas_ews_example \ +ecore_evas_object_example \ +ecore_evas_window_sizes_example \ +ecore_event_example_01 \ +ecore_event_example_02 \ +ecore_exe_example \ +ecore_exe_example_child \ +ecore_fd_handler_example \ +ecore_idler_example \ +ecore_job_example \ +ecore_pipe_simple_example \ +ecore_poller_example \ +ecore_server_bench \ +ecore_thread_example \ +ecore_time_functions_example \ +ecore_timer_example + +EXTRA_DIST = red.png + +examples: $(EXTRA_PROGRAMS) + +clean-local: + rm -f $(EXTRA_PROGRAMS) + +install-examples: + mkdir -p $(datadir)/ecore/examples + $(install_sh_DATA) -c $(SRCS) $(datadir)/ecore/examples + $(install_sh_DATA) -c red.png $(datadir)/ecore/examples + +uninstall-local: + rm -f $(datadir)/ecore/examples/red.png + for f in $(SRCS) ; do \ + rm -f $(datadir)/ecore/examples/$$f ; \ + done diff --git a/src/examples/ecore/ecore_animator_example.c b/src/examples/ecore/ecore_animator_example.c new file mode 100644 index 0000000000..545d48a1e4 --- /dev/null +++ b/src/examples/ecore/ecore_animator_example.c @@ -0,0 +1,117 @@ +//Compile with: +//gcc -g -Wall `pkg-config --cflags --libs ecore-evas` -o ecore_animator_example ecore_animator_example.c + +#include +#include + +static Eina_Bool _advance_frame(void *data, double pos); +static Eina_Bool _advance_frame2(void *data, double pos); +static Eina_Bool _advance_frame3(void *data); +static Eina_Bool _start_second_anim(void *data); +static Eina_Bool _freeze_third_anim(void *data); +static Eina_Bool _thaw_third_anim(void *data); + +int +main(int argc, char *argv[]) +{ + Evas_Object *rect, *bg, *rect2; + Ecore_Evas *ee; + Evas *evas; + Ecore_Animator *anim; + + ecore_evas_init(); + + ee = ecore_evas_new(NULL, 0, 0, 300, 400, NULL); + ecore_evas_show(ee); + evas = ecore_evas_get(ee); + + bg = evas_object_rectangle_add(evas); + evas_object_resize(bg, 300, 400); + evas_object_show(bg); + + rect = evas_object_rectangle_add(evas); + evas_object_color_set(rect, 0, 0, 255, 255); + evas_object_resize(rect, 50, 50); + evas_object_show(rect); + + rect2 = evas_object_rectangle_add(evas); + evas_object_color_set(rect2, 0, 55, 0, 255); + evas_object_resize(rect2, 50, 50); + evas_object_show(rect2); + + ecore_animator_frametime_set(1. / 50); + ecore_animator_timeline_add(5, _advance_frame, rect); + + anim = ecore_animator_add(_advance_frame3, rect2); + + ecore_timer_add(10, _start_second_anim, rect); + ecore_timer_add(5, _freeze_third_anim, anim); + ecore_timer_add(10, _thaw_third_anim, anim); + ecore_main_loop_begin(); + + evas_object_del(rect); + ecore_evas_free(ee); + ecore_animator_del(anim); + ecore_evas_shutdown(); + + return 0; +} + +static Eina_Bool +_advance_frame(void *data, double pos) +{ + double frame = pos; + frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_SPRING, 1.2, 15); + + evas_object_resize(data, 50 * (1 + frame), 50 * (1 + frame)); + evas_object_move(data, 100 * frame, 100 * frame); + evas_object_color_set(data, 255 * frame, 0, 255 * (1 - frame), 255); + return EINA_TRUE; +} + +static Eina_Bool +_start_second_anim(void *data) +{ + ecore_animator_frametime_set(1. / 10); + ecore_animator_timeline_add(20, _advance_frame2, data); + return EINA_FALSE; +} + +static Eina_Bool +_advance_frame2(void *data, double pos) +{ + double frame = pos; + frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_BOUNCE, 1.2, 50); + + evas_object_resize(data, 100 - (50 * frame), 100 - (50 * frame)); + evas_object_move(data, 100 * (1 - frame), 100 * (1 - frame)); + evas_object_color_set(data, 255 * (1 - frame), 0, 255 * frame, 255); + return EINA_TRUE; +} + +static Eina_Bool +_advance_frame3(void *data) +{ + static int x = 0; + + if (x >= 250) + x = 0; + evas_object_move(data, ++x, 350); + + return EINA_TRUE; +} + +static Eina_Bool +_freeze_third_anim(void *data) +{ + ecore_animator_freeze(data); + return EINA_FALSE; +} + +static Eina_Bool +_thaw_third_anim(void *data) +{ + ecore_animator_thaw(data); + return EINA_FALSE; +} + diff --git a/src/examples/ecore/ecore_client_bench.c b/src/examples/ecore/ecore_client_bench.c new file mode 100644 index 0000000000..dc550eea74 --- /dev/null +++ b/src/examples/ecore/ecore_client_bench.c @@ -0,0 +1,79 @@ +#include +#include +#include + +/* Ecore_Con client example + * 2010 Mike Blumenkrantz + */ + +#define NUM_CLIENTS 30000 + +static Eina_Counter *counter; +static int add = 0; +static int del = 0; + +Eina_Bool +_add(void *data, int type, Ecore_Con_Event_Server_Add *ev) +{ + ++add; + printf("Connection #%i!\n", add); + if (add == NUM_CLIENTS) + ecore_main_loop_quit(); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data, int type, Ecore_Con_Event_Server_Add *ev) +{ + ++del; + printf("Connection lost! #%i!\n", del); + + return ECORE_CALLBACK_RENEW; +} + +static void +_spawn(void *data) +{ + int x; + + for (x = 0; x < NUM_CLIENTS; x++) + { +// printf("Creating connection %i\n", x); + if (!ecore_con_server_connect(ECORE_CON_REMOTE_NODELAY, "127.0.0.1", 8080, NULL)) + { + printf("CRITICAL ERROR!\n" + "Could not create connection #%i!\n", x); + exit(1); + } + } + printf("***Job done***\n"); +} + +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; +} + diff --git a/src/examples/ecore/ecore_con_client_example.c b/src/examples/ecore/ecore_con_client_example.c new file mode 100644 index 0000000000..c6ab50d6ca --- /dev/null +++ b/src/examples/ecore/ecore_con_client_example.c @@ -0,0 +1,92 @@ +#include +#include +#include + +/* Ecore_Con client example + * 2010 Mike Blumenkrantz + */ + +/* comment if not using gnutls */ +static void +tls_log_func(int level, const char *str) +{ + fprintf(stderr, "|<%d>| %s", level, str); +} + +Eina_Bool +_add(void *data, int type, Ecore_Con_Event_Server_Add *ev) +{ + printf("Server with ip %s connected!\n", ecore_con_server_ip_get(ev->server)); + ecore_con_server_send(ev->server, "hello!", 6); + ecore_con_server_flush(ev->server); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data, int type, Ecore_Con_Event_Server_Del *ev) +{ + printf("Lost server with ip %s!\n", ecore_con_server_ip_get(ev->server)); + ecore_main_loop_quit(); + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_data(void *data, int type, Ecore_Con_Event_Server_Data *ev) +{ + char fmt[128]; + + snprintf(fmt, sizeof(fmt), + "Received %i bytes from server:\n" + ">>>>>\n" + "%%.%is\n" + ">>>>>\n", + ev->size, ev->size); + + printf(fmt, ev->data); + return ECORE_CALLBACK_RENEW; +} + +int +main() +{ + Ecore_Con_Server *svr; + Eina_Iterator *it; + const char *ca; + + eina_init(); + ecore_init(); + ecore_con_init(); + +/* comment if not using gnutls */ + gnutls_global_set_log_level(9); + gnutls_global_set_log_function(tls_log_func); + + if (!(it = eina_file_ls("/etc/ssl/certs"))) + exit(1); + + if (!(svr = ecore_con_server_connect(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_MIXED, "www.verisign.com", 443, NULL))) + exit(1); + + /* add all the CAs */ + EINA_ITERATOR_FOREACH(it, ca) + { + if (!ecore_con_ssl_server_cafile_add(svr, ca)) + printf("Could not load CA: %s!\n", ca); + eina_stringshare_del(ca); + } + + eina_iterator_free(it); + ecore_con_ssl_server_verify(svr); + +/* set event handler for server connect */ + ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, NULL); +/* set event handler for server disconnect */ + ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL, (Ecore_Event_Handler_Cb)_del, NULL); +/* set event handler for receiving server data */ + ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA, (Ecore_Event_Handler_Cb)_data, NULL); + +/* start client */ + ecore_main_loop_begin(); +} + diff --git a/src/examples/ecore/ecore_con_client_simple_example.c b/src/examples/ecore/ecore_con_client_simple_example.c new file mode 100644 index 0000000000..48b1933ca7 --- /dev/null +++ b/src/examples/ecore/ecore_con_client_simple_example.c @@ -0,0 +1,126 @@ +#include +#include +#include + +#ifdef HAVE_CONFIG_H +# include "config.h" +#else +# define EINA_UNUSED +#endif + +struct _Server +{ + int sdata; +}; + +Eina_Bool +_add(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Server_Add *ev) +{ + char welcome[] = "hello! - sent from the client"; + struct _Server *server = malloc(sizeof(*server)); + server->sdata = 0; + + ecore_con_server_data_set(ev->server, server); + printf("Server with ip %s, name %s, port %d, connected = %d!\n", + ecore_con_server_ip_get(ev->server), + ecore_con_server_name_get(ev->server), + ecore_con_server_port_get(ev->server), + ecore_con_server_connected_get(ev->server)); + ecore_con_server_send(ev->server, welcome, sizeof(welcome)); + ecore_con_server_flush(ev->server); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Server_Del *ev) +{ + if (!ev->server) + { + printf("Failed to establish connection to the server.\nExiting.\n"); + ecore_main_loop_quit(); + return ECORE_CALLBACK_RENEW; + } + + struct _Server *server = ecore_con_server_data_get(ev->server); + + printf("Lost server with ip %s!\n", ecore_con_server_ip_get(ev->server)); + + if (server) + { + printf("Total data received from this server: %d\n", server->sdata); + free(server); + } + + ecore_con_server_del(ev->server); + + ecore_main_loop_quit(); + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Server_Data *ev) +{ + char fmt[128]; + struct _Server *server = ecore_con_server_data_get(ev->server); + + snprintf(fmt, sizeof(fmt), + "Received %i bytes from server:\n" + ">>>>>\n" + "%%.%is\n" + ">>>>>\n", + ev->size, ev->size); + + printf(fmt, ev->data); + + server->sdata += ev->size; + return ECORE_CALLBACK_RENEW; +} + +int +main(int argc, const char *argv[]) +{ + Ecore_Con_Server *svr; + const char *address; + int port = 8080; + + if (argc < 2) + { + printf("wrong usage. Command syntax is:\n"); + printf("\tecore_con_client_simple_example
[port]\n"); + exit(1); + } + + address = argv[1]; + + if (argc > 2) + port = atoi(argv[2]); + + eina_init(); + ecore_init(); + ecore_con_init(); + + if (!(svr = ecore_con_server_connect(ECORE_CON_REMOTE_TCP, address, port, NULL))) + { + printf("could not connect to the server: %s, port %d.\n", + address, port); + exit(2); + } + + /* set event handler for server connect */ + ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, NULL); + /* set event handler for server disconnect */ + ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL, (Ecore_Event_Handler_Cb)_del, NULL); + /* set event handler for receiving server data */ + ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA, (Ecore_Event_Handler_Cb)_data, NULL); + + /* start client */ + ecore_main_loop_begin(); + + ecore_con_init(); + ecore_init(); + eina_init(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_con_lookup_example.c b/src/examples/ecore/ecore_con_lookup_example.c new file mode 100644 index 0000000000..1a47d0ba32 --- /dev/null +++ b/src/examples/ecore/ecore_con_lookup_example.c @@ -0,0 +1,40 @@ +#include +#include +#include + +static void +_lookup_done_cb(const char *canonname, const char *ip, struct sockaddr *addr, int addrlen, void *data) +{ + printf("canonname = %s\n", canonname); + printf("ip = %s\n", ip); + printf("addr = %p\n", addr); + printf("addrlen = %d\n", addrlen); +} + +int +main(int argc, const char *argv[]) +{ + if (argc < 2) + { + printf("need one parameter:
\n"); + return -1; + } + + ecore_init(); + ecore_con_init(); + + if (!ecore_con_lookup(argv[1], _lookup_done_cb, NULL)) + { + printf("error when trying to start lookup for %s\n", argv[1]); + goto end; + } + + ecore_main_loop_begin(); + +end: + ecore_con_shutdown(); + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_con_server_example.c b/src/examples/ecore/ecore_con_server_example.c new file mode 100644 index 0000000000..73335216f5 --- /dev/null +++ b/src/examples/ecore/ecore_con_server_example.c @@ -0,0 +1,81 @@ +#include +#include +#include + +/* Ecore_Con server example + * 2010 Mike Blumenkrantz + */ + +/* comment if not using gnutls */ +static void +tls_log_func(int level, const char *str) +{ + fprintf(stderr, "|<%d>| %s", level, str); +} + +Eina_Bool +_add(void *data, int type, Ecore_Con_Event_Client_Add *ev) +{ + printf("Client with ip %s connected!\n", ecore_con_client_ip_get(ev->client)); + ecore_con_client_send(ev->client, "hello!", 6); +// ecore_con_client_flush(ev->client); + ecore_con_client_timeout_set(ev->client, 5); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data, int type, Ecore_Con_Event_Client_Del *ev) +{ + printf("Lost client with ip %s!\n", ecore_con_client_ip_get(ev->client)); + ecore_main_loop_quit(); + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_data(void *data, int type, Ecore_Con_Event_Client_Data *ev) +{ + char fmt[128]; + + snprintf(fmt, sizeof(fmt), + "Received %i bytes from client:\n" + ">>>>>\n" + "%%.%is\n" + ">>>>>\n", + ev->size, ev->size); + + printf(fmt, ev->data); + return ECORE_CALLBACK_RENEW; +} + +int +main() +{ + Ecore_Con_Server *svr; + eina_init(); + ecore_init(); + ecore_con_init(); + +/* comment if not using gnutls */ + gnutls_global_set_log_level(9); + gnutls_global_set_log_function(tls_log_func); + +/* to use a PEM certificate with TLS and SSL3, uncomment the lines below */ + if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_TLS | ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT, "127.0.0.1", 8080, NULL))) +/* to use simple tcp with ssl/tls, use this line */ +// if (!ecore_con_server_add(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_SSL3, "127.0.0.1", 8080, NULL)) + exit(1); + + ecore_con_ssl_server_cert_add(svr, "server.pem"); + ecore_con_ssl_server_privkey_add(svr, "server.pem"); +/* set event handler for client connect */ + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL); +/* set event handler for client disconnect */ + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL); +/* set event handler for receiving client data */ + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_data, NULL); + +/* start server */ + ecore_main_loop_begin(); +} + diff --git a/src/examples/ecore/ecore_con_server_http_example.c b/src/examples/ecore/ecore_con_server_http_example.c new file mode 100644 index 0000000000..14d1ecb5b0 --- /dev/null +++ b/src/examples/ecore/ecore_con_server_http_example.c @@ -0,0 +1,136 @@ +#include +#include +#include +#include + +#ifdef HAVE_CONFIG_H +# include "config.h" +#else +# define EINA_UNUSED +#endif + +static const char response_template[] = + "HTTP/1.0 200 OK\r\n" + "Server: Ecore_Con custom server\r\n" + "Content-Length: %zd\r\n" + "Content-Type: text/html; charset=UTF-8\r\n" + "Set-Cookie: MYCOOKIE=1; path=/; expires=%s\r\n" + "Set-Cookie: SESSIONCOOKIE=1; path=/\r\n" + "\r\n" + "%s"; + +struct _Client +{ + int sdata; +}; + +Eina_Bool +_add(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Add *ev) +{ + struct _Client *client = malloc(sizeof(*client)); + client->sdata = 0; + static char buf[4096]; + char welcome[] = "Welcome to Ecore_Con server!"; + time_t t; + + printf("Client with ip %s, port %d, connected = %d!\n", + ecore_con_client_ip_get(ev->client), + ecore_con_client_port_get(ev->client), + ecore_con_client_connected_get(ev->client)); + + ecore_con_client_data_set(ev->client, client); + + t = time(NULL); + t += 60 * 60 * 24; + snprintf(buf, sizeof(buf), response_template, sizeof(welcome) - 1, ctime(&t), welcome); + + ecore_con_client_send(ev->client, buf, strlen(buf)); + ecore_con_client_flush(ev->client); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Del *ev) +{ + struct _Client *client; + + if (!ev->client) + return ECORE_CALLBACK_RENEW; + + client = ecore_con_client_data_get(ev->client); + + printf("Lost client with ip %s!\n", ecore_con_client_ip_get(ev->client)); + printf("Total data received from this client: %d\n", client->sdata); + printf("Client was connected for %0.3f seconds.\n", + ecore_con_client_uptime_get(ev->client)); + + if (client) + free(client); + + ecore_con_client_del(ev->client); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Data *ev) +{ + char fmt[128]; + struct _Client *client = ecore_con_client_data_get(ev->client); + + snprintf(fmt, sizeof(fmt), + "\nReceived %i bytes from client %s port %d:\n" + ">>>>>\n" + "%%.%is\n" + ">>>>>\n\n", + ev->size, ecore_con_client_ip_get(ev->client), + ecore_con_client_port_get(ev->client), ev->size); + + printf(fmt, ev->data); + + client->sdata += ev->size; + + return ECORE_CALLBACK_RENEW; +} + +int +main(void) +{ + Ecore_Con_Server *svr; + Ecore_Con_Client *cl; + const Eina_List *clients, *l; + + eina_init(); + ecore_init(); + ecore_con_init(); + + if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_TCP, "127.0.0.1", 8080, NULL))) + exit(1); + + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_data, NULL); + ecore_con_server_client_limit_set(svr, 3, 0); + + ecore_main_loop_begin(); + + clients = ecore_con_server_clients_get(svr); + printf("Clients still connected to this server when exiting: %d\n", + eina_list_count(clients)); + EINA_LIST_FOREACH(clients, l, cl) + { + printf("%s\n", ecore_con_client_ip_get(cl)); + free(ecore_con_client_data_get(cl)); + } + + printf("Server was up for %0.3f seconds\n", + ecore_con_server_uptime_get(svr)); + + ecore_con_shutdown(); + ecore_shutdown(); + eina_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_con_server_simple_example.c b/src/examples/ecore/ecore_con_server_simple_example.c new file mode 100644 index 0000000000..c771b2af3e --- /dev/null +++ b/src/examples/ecore/ecore_con_server_simple_example.c @@ -0,0 +1,133 @@ +#include +#include +#include + +#ifdef HAVE_CONFIG_H +# include "config.h" +#else +# define EINA_UNUSED +#endif + +struct _Client +{ + int sdata; +}; + +Eina_Bool +_add(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Add *ev) +{ + char welcome[] = "hello! - sent from the server"; + Ecore_Con_Server *srv; + Ecore_Con_Client *cl; + const Eina_List *clients, *l; + + struct _Client *client = malloc(sizeof(*client)); + client->sdata = 0; + + printf("Client with ip %s, port %d, connected = %d!\n", + ecore_con_client_ip_get(ev->client), + ecore_con_client_port_get(ev->client), + ecore_con_client_connected_get(ev->client)); + + ecore_con_client_send(ev->client, welcome, sizeof(welcome)); + ecore_con_client_flush(ev->client); + + ecore_con_client_timeout_set(ev->client, 6); + + ecore_con_client_data_set(ev->client, client); + + srv = ecore_con_client_server_get(ev->client); + printf("Clients connected to this server:\n"); + clients = ecore_con_server_clients_get(srv); + EINA_LIST_FOREACH(clients, l, cl) + printf("%s\n", ecore_con_client_ip_get(cl)); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Del *ev) +{ + struct _Client *client; + + if (!ev->client) + return ECORE_CALLBACK_RENEW; + + client = ecore_con_client_data_get(ev->client); + + printf("Lost client with ip %s!\n", ecore_con_client_ip_get(ev->client)); + printf("Total data received from this client: %d\n", client->sdata); + printf("Client was connected for %0.3f seconds.\n", + ecore_con_client_uptime_get(ev->client)); + + if (client) + free(client); + + ecore_con_client_del(ev->client); + + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Data *ev) +{ + char fmt[128]; + struct _Client *client = ecore_con_client_data_get(ev->client); + + snprintf(fmt, sizeof(fmt), + "Received %i bytes from client %s port %d:\n" + ">>>>>\n" + "%%.%is\n" + ">>>>>\n", + ev->size, ecore_con_client_ip_get(ev->client), + ecore_con_client_port_get(ev->client), ev->size); + + printf(fmt, ev->data); + + client->sdata += ev->size; + + return ECORE_CALLBACK_RENEW; +} + +int +main(void) +{ + Ecore_Con_Server *svr; + Ecore_Con_Client *cl; + const Eina_List *clients, *l; + + eina_init(); + ecore_init(); + ecore_con_init(); + + if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_TCP, "127.0.0.1", 8080, NULL))) + exit(1); + + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_data, NULL); + + ecore_con_server_timeout_set(svr, 10); + ecore_con_server_client_limit_set(svr, 3, 0); + + ecore_main_loop_begin(); + + clients = ecore_con_server_clients_get(svr); + printf("Clients connected to this server when exiting: %d\n", + eina_list_count(clients)); + EINA_LIST_FOREACH(clients, l, cl) + { + printf("%s\n", ecore_con_client_ip_get(cl)); + free(ecore_con_client_data_get(cl)); + } + + printf("Server was up for %0.3f seconds\n", + ecore_con_server_uptime_get(svr)); + + ecore_con_shutdown(); + ecore_shutdown(); + eina_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_con_url_cookies_example.c b/src/examples/ecore/ecore_con_url_cookies_example.c new file mode 100644 index 0000000000..908df0f2a0 --- /dev/null +++ b/src/examples/ecore/ecore_con_url_cookies_example.c @@ -0,0 +1,123 @@ +#include +#include +#include +#include + +#ifdef HAVE_CONFIG_H +# include "config.h" +#else +# define EINA_UNUSED +#endif + +#define COOKIEJAR "cookies.jar" + +static Eina_Bool +_url_data_cb(void *data EINA_UNUSED, int type EINA_UNUSED, void *event_info) +{ + Ecore_Con_Event_Url_Data *url_data = event_info; + int i; + + printf("\nData received from server:\n>>>>>\n"); + for (i = 0; i < url_data->size; i++) + printf("%c", url_data->data[i]); + printf("\n>>>>>>\n\n"); + + return EINA_TRUE; +} + +static Eina_Bool +_url_complete_cb(void *data EINA_UNUSED, int type EINA_UNUSED, void *event_info) +{ + Ecore_Con_Event_Url_Complete *url_complete = event_info; + const Eina_List *headers, *l; + char *str; + + printf("\n"); + printf("download completed with status code: %d\n", url_complete->status); + + headers = ecore_con_url_response_headers_get(url_complete->url_con); + + printf("response headers:\n"); + EINA_LIST_FOREACH(headers, l, str) + printf("header: %s", str); + + ecore_con_url_cookies_jar_write(url_complete->url_con); + + ecore_main_loop_quit(); + + return EINA_TRUE; +} + +int +main(int argc, const char *argv[]) +{ + Ecore_Con_Url *ec_url = NULL; + char cmd = '\0'; + Eina_Bool r; + + if (argc < 2) + { + printf("need at least one parameter: [command]\n"); + return -1; + } + + if (argc > 2) + cmd = argv[2][0]; + + ecore_init(); + ecore_con_init(); + ecore_con_url_init(); + + ec_url = ecore_con_url_new(argv[1]); + if (!ec_url) + { + printf("error when creating ecore con url object.\n"); + goto end; + } + + ecore_event_handler_add(ECORE_CON_EVENT_URL_DATA, _url_data_cb, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_URL_COMPLETE, _url_complete_cb, NULL); + + ecore_con_url_additional_header_add(ec_url, "User-Agent", "Ecore_Con client"); + + ecore_con_url_cookies_init(ec_url); + if (cmd != 'c' && cmd != 's') + ecore_con_url_cookies_file_add(ec_url, COOKIEJAR); + ecore_con_url_cookies_jar_file_set(ec_url, COOKIEJAR); + + switch (cmd) + { + case 'c': // clear + printf("Cleaning previously set cookies.\n"); + ecore_con_url_cookies_clear(ec_url); + break; + + case 's': // clear session + printf("Cleaning previously set session cookies.\n"); + ecore_con_url_cookies_session_clear(ec_url); + break; + + case 'i': // ignore session + printf("Ignoring old session cookies.\n"); + ecore_con_url_cookies_ignore_old_session_set(ec_url, EINA_TRUE); + } + + r = ecore_con_url_get(ec_url); + if (!r) + { + printf("could not realize request.\n"); + goto free_ec_url; + } + + ecore_main_loop_begin(); + +free_ec_url: + ecore_con_url_free(ec_url); +end: + ecore_con_url_shutdown(); + ecore_con_shutdown(); + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_con_url_download_example.c b/src/examples/ecore/ecore_con_url_download_example.c new file mode 100644 index 0000000000..6eed89afdc --- /dev/null +++ b/src/examples/ecore/ecore_con_url_download_example.c @@ -0,0 +1,115 @@ +#include +#include +#include +#include +#include + +#include +#include + +struct _request +{ + long size; +}; + +static Eina_Bool +_url_progress_cb(void *data, int type, void *event_info) +{ + Ecore_Con_Event_Url_Progress *url_progress = event_info; + float percent; + + if (url_progress->down.total > 0) + { + struct _request *req = ecore_con_url_data_get(url_progress->url_con); + req->size = url_progress->down.now; + + percent = (url_progress->down.now / url_progress->down.total) * 100; + printf("Total of download complete: %0.1f (%0.0f)%%\n", + percent, url_progress->down.now); + } + + return EINA_TRUE; +} + +static Eina_Bool +_url_complete_cb(void *data, int type, void *event_info) +{ + Ecore_Con_Event_Url_Complete *url_complete = event_info; + + struct _request *req = ecore_con_url_data_get(url_complete->url_con); + int nbytes = ecore_con_url_received_bytes_get(url_complete->url_con); + + printf("\n"); + printf("download completed with status code: %d\n", url_complete->status); + printf("Total size of downloaded file: %ld bytes\n", req->size); + printf("Total size of downloaded file: %d bytes " + "(from received_bytes_get)\n", nbytes); + ecore_main_loop_quit(); + + return EINA_TRUE; +} + +int +main(int argc, const char *argv[]) +{ + Ecore_Con_Url *ec_url = NULL; + struct _request *req; + int fd; + const char *filename = "downloadedfile.dat"; + + if (argc < 2) + { + printf("need one parameter: \n"); + return -1; + } + + fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644); + + if (fd == -1) + { + printf("error: could not open file for writing: \"%s\"\n", + filename); + return -1; + } + + ecore_init(); + ecore_con_init(); + ecore_con_url_init(); + + ec_url = ecore_con_url_new(argv[1]); + if (!ec_url) + { + printf("error when creating ecore con url object.\n"); + goto end; + } + + req = malloc(sizeof(*req)); + req->size = 0; + ecore_con_url_data_set(ec_url, req); + + ecore_con_url_fd_set(ec_url, fd); + + ecore_event_handler_add(ECORE_CON_EVENT_URL_PROGRESS, _url_progress_cb, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_URL_COMPLETE, _url_complete_cb, NULL); + + if (!ecore_con_url_get(ec_url)) + { + printf("could not realize request.\n"); + goto free_ec_url; + } + + ecore_main_loop_begin(); + +free_ec_url: + free(req); + ecore_con_url_free(ec_url); +end: + + close(fd); + ecore_con_url_shutdown(); + ecore_con_shutdown(); + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_con_url_headers_example.c b/src/examples/ecore/ecore_con_url_headers_example.c new file mode 100644 index 0000000000..fb05df35ea --- /dev/null +++ b/src/examples/ecore/ecore_con_url_headers_example.c @@ -0,0 +1,106 @@ +#include +#include +#include +#include + +static Eina_Bool +_url_data_cb(void *data, int type, void *event_info) +{ + Ecore_Con_Event_Url_Data *url_data = event_info; + int i; + + for (i = 0; i < url_data->size; i++) + printf("%c", url_data->data[i]); + + return EINA_TRUE; +} + +static Eina_Bool +_url_complete_cb(void *data, int type, void *event_info) +{ + Ecore_Con_Event_Url_Complete *url_complete = event_info; + const Eina_List *headers, *l; + char *str; + + printf("\n"); + printf("download completed with status code: %d\n", url_complete->status); + + headers = ecore_con_url_response_headers_get(url_complete->url_con); + + EINA_LIST_FOREACH(headers, l, str) + printf("header: %s\n", str); + + ecore_main_loop_quit(); + + return EINA_TRUE; +} + +int +main(int argc, const char *argv[]) +{ + Ecore_Con_Url *ec_url = NULL; + const char *type; + Eina_Bool r; + + if (argc < 3) + { + printf("need at least two parameters: < POST|GET > \n"); + return -1; + } + + type = argv[1]; + + if (strcmp(type, "POST") && (strcmp(type, "GET"))) + { + printf("only POST or GET are supported by this example.\n"); + return -1; + } + + ecore_init(); + ecore_con_init(); + ecore_con_url_init(); + + // check if requests are being pipelined, and set them if not: + if (!ecore_con_url_pipeline_get()) + ecore_con_url_pipeline_set(EINA_TRUE); + + ec_url = ecore_con_url_custom_new(argv[2], type); + if (!ec_url) + { + printf("error when creating ecore con url object.\n"); + goto end; + } + + ecore_event_handler_add(ECORE_CON_EVENT_URL_DATA, _url_data_cb, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_URL_COMPLETE, _url_complete_cb, NULL); + + ecore_con_url_additional_header_add(ec_url, "User-Agent", "blablabla"); + ecore_con_url_verbose_set(ec_url, EINA_TRUE); + + ecore_con_url_httpauth_set(ec_url, "user", "password", EINA_FALSE); + + ecore_con_url_time(ec_url, ECORE_CON_URL_TIME_IFMODSINCE, 0); + + if (!strcmp(type, "GET")) + r = ecore_con_url_get(ec_url); + else + r = ecore_con_url_post(ec_url, NULL, 0, NULL); + + if (!r) + { + printf("could not realize request.\n"); + goto free_ec_url; + } + + ecore_main_loop_begin(); + +free_ec_url: + ecore_con_url_free(ec_url); +end: + ecore_con_url_shutdown(); + ecore_con_shutdown(); + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_evas_basics_example.c b/src/examples/ecore/ecore_evas_basics_example.c new file mode 100644 index 0000000000..b62c64ad72 --- /dev/null +++ b/src/examples/ecore/ecore_evas_basics_example.c @@ -0,0 +1,89 @@ +/** + * Ecore example illustrating the basics of ecore evas usage. + * + * You'll need at least one Evas engine built for it (excluding the + * buffer one). See stdout/stderr for output. + * + * @verbatim + * gcc -o ecore_evas_basics_example ecore_evas_basics_example.c `pkg-config --libs --cflags ecore-evas` + * @endverbatim + */ + +#include +#include +#include + +static Eina_Bool +_stdin_cb(void *data, Ecore_Fd_Handler *handler) +{ + Eina_List *l; + Ecore_Evas *ee; + char c; + + scanf("%c", &c); + if (c == 'h') + EINA_LIST_FOREACH(ecore_evas_ecore_evas_list_get(), l, ee) + ecore_evas_hide(ee); + else if (c == 's') + EINA_LIST_FOREACH(ecore_evas_ecore_evas_list_get(), l, ee) + ecore_evas_show(ee); + + return ECORE_CALLBACK_RENEW; +} + +static void +_on_delete(Ecore_Evas *ee) +{ + free(ecore_evas_data_get(ee, "key")); + ecore_main_loop_quit(); +} + +int +main(void) +{ + Ecore_Evas *ee; + Evas *canvas; + Evas_Object *bg; + Eina_List *engines, *l; + char *data; + + if (ecore_evas_init() <= 0) + return 1; + + engines = ecore_evas_engines_get(); + printf("Available engines:\n"); + EINA_LIST_FOREACH(engines, l, data) + printf("%s\n", data); + ecore_evas_engines_free(engines); + + ee = ecore_evas_new(NULL, 0, 0, 200, 200, NULL); + ecore_evas_title_set(ee, "Ecore Evas basics Example"); + ecore_evas_show(ee); + + data = malloc(sizeof(char) * 6); + sprintf(data, "%s", "hello"); + ecore_evas_data_set(ee, "key", data); + ecore_evas_callback_delete_request_set(ee, _on_delete); + + printf("Using %s engine!\n", ecore_evas_engine_name_get(ee)); + + canvas = ecore_evas_get(ee); + if (ecore_evas_ecore_evas_get(canvas) == ee) + printf("Everything is sane!\n"); + + bg = evas_object_rectangle_add(canvas); + evas_object_color_set(bg, 0, 0, 255, 255); + evas_object_resize(bg, 200, 200); + evas_object_show(bg); + ecore_evas_object_associate(ee, bg, ECORE_EVAS_OBJECT_ASSOCIATE_BASE); + + ecore_main_fd_handler_add(STDIN_FILENO, ECORE_FD_READ, _stdin_cb, NULL, NULL, NULL); + + ecore_main_loop_begin(); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_evas_buffer_example_01.c b/src/examples/ecore/ecore_evas_buffer_example_01.c new file mode 100644 index 0000000000..39f6dd11d7 --- /dev/null +++ b/src/examples/ecore/ecore_evas_buffer_example_01.c @@ -0,0 +1,121 @@ +/** + * Simple Ecore_Evas example on the Evas buffer engine wrapper + * functions. + * + * You must have Evas compiled with the buffer engine. + * + * Compile with: + * + * @verbatim + * gcc -o evas-buffer-simple evas-buffer-simple.c `pkg-config --libs --cflags evas evas-software-buffer` + * @endverbatim + * + */ + +#ifdef HAVE_CONFIG_H + +#include "config.h" +#else +#define EINA_UNUSED +#endif + +#include +#include + +#define WIDTH (320) +#define HEIGHT (240) + +static Ecore_Evas *ee; + +/* support function to save scene as PPM image */ +static void +_scene_save(Evas *canvas, + const char *dest) +{ + const unsigned int *pixels, *pixels_end; + int width, height; + FILE *f; + + evas_output_size_get(canvas, &width, &height); + + f = fopen(dest, "wb+"); + if (!f) + { + fprintf(stderr, "ERROR: could not open for writing '%s': %s\n", + dest, strerror(errno)); + return; + } + + pixels = ecore_evas_buffer_pixels_get(ee); + pixels_end = pixels + (width * height); + + /* PPM P6 format is dead simple to write: */ + fprintf(f, "P6\n%d %d\n255\n", width, height); + for (; pixels < pixels_end; pixels++) + { + int r, g, b; + + r = ((*pixels) & 0xff0000) >> 16; + g = ((*pixels) & 0x00ff00) >> 8; + b = (*pixels) & 0x0000ff; + + fprintf(f, "%c%c%c", r, g, b); + } + + fclose(f); + printf("Saved scene as '%s'\n", dest); +} + +int +main(void) +{ + Evas *canvas; + Evas_Object *bg, *r1, *r2, *r3; + + ecore_evas_init(); + + ee = ecore_evas_buffer_new(WIDTH, HEIGHT); + if (!ee) goto error; + + canvas = ecore_evas_get(ee); + + bg = evas_object_rectangle_add(canvas); + evas_object_color_set(bg, 255, 255, 255, 255); /* white bg */ + evas_object_move(bg, 0, 0); /* at origin */ + evas_object_resize(bg, WIDTH, HEIGHT); /* covers full canvas */ + evas_object_show(bg); + + r1 = evas_object_rectangle_add(canvas); + evas_object_color_set(r1, 255, 0, 0, 255); /* 100% opaque red */ + evas_object_move(r1, 10, 10); + evas_object_resize(r1, 100, 100); + evas_object_show(r1); + + r2 = evas_object_rectangle_add(canvas); + evas_object_color_set(r2, 0, 128, 0, 128); /* 50% opaque green */ + evas_object_move(r2, 10, 10); + evas_object_resize(r2, 50, 50); + evas_object_show(r2); + + r3 = evas_object_rectangle_add(canvas); + evas_object_color_set(r3, 0, 128, 0, 255); /* 100% opaque dark green */ + evas_object_move(r3, 60, 60); + evas_object_resize(r3, 50, 50); + evas_object_show(r3); + + ecore_evas_manual_render(ee); + _scene_save(canvas, "/tmp/evas-buffer-simple-render.ppm"); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; + +error: + fprintf(stderr, "You got to have at least one Evas engine built" + " and linked up to ecore-evas for this example to run" + " properly.\n"); + ecore_evas_shutdown(); + return -1; +} + diff --git a/src/examples/ecore/ecore_evas_buffer_example_02.c b/src/examples/ecore/ecore_evas_buffer_example_02.c new file mode 100644 index 0000000000..d30d764867 --- /dev/null +++ b/src/examples/ecore/ecore_evas_buffer_example_02.c @@ -0,0 +1,126 @@ +/** + * Simple Ecore_Evas example on the Evas buffer engine wrapper + * functions. + * + * You must have Evas compiled with the buffer engine. + * + * Compile with: + * + * @verbatim + * gcc -o evas-buffer-simple evas-buffer-simple.c `pkg-config --libs --cflags evas evas-software-buffer` + * @endverbatim + * + */ + +#ifdef HAVE_CONFIG_H + +#include "config.h" +#else +#define EINA_UNUSED +#define PACKAGE_EXAMPLES_DIR "." +#endif + +#include +#include +#include + +#define WIDTH (320) +#define HEIGHT (240) + +static Ecore_Evas *ee; +static const char *border_img_path = PACKAGE_EXAMPLES_DIR "/red.png"; + +static void +_on_destroy(Ecore_Evas *ee EINA_UNUSED) +{ + ecore_main_loop_quit(); +} + +int +main(void) +{ + Evas *canvas, *sub_canvas; + Evas_Object *bg, *r1, *r2, *r3; /* "sub" canvas objects */ + Evas_Object *border, *img; /* canvas objects */ + Ecore_Evas *sub_ee; + + ecore_evas_init(); + + /* this will give you a window with an Evas canvas under the first + * engine available */ + ee = ecore_evas_new(NULL, 0, 0, WIDTH, HEIGHT, NULL); + if (!ee) goto error; + + ecore_evas_size_min_set(ee, WIDTH, HEIGHT); + ecore_evas_size_max_set(ee, WIDTH, HEIGHT); + + ecore_evas_callback_delete_request_set(ee, _on_destroy); + ecore_evas_title_set(ee, "Ecore_Evas buffer (image) example"); + ecore_evas_show(ee); + + canvas = ecore_evas_get(ee); + + bg = evas_object_rectangle_add(canvas); + evas_object_color_set(bg, 255, 255, 255, 255); /* white bg */ + evas_object_move(bg, 0, 0); /* at origin */ + evas_object_resize(bg, WIDTH, HEIGHT); /* covers full canvas */ + evas_object_show(bg); + + /* this is a border around the image containing a scene of another + * canvas */ + border = evas_object_image_filled_add(canvas); + evas_object_image_file_set(border, border_img_path, NULL); + evas_object_image_border_set(border, 3, 3, 3, 3); + evas_object_image_border_center_fill_set(border, EVAS_BORDER_FILL_NONE); + + evas_object_move(border, WIDTH / 6, HEIGHT / 6); + evas_object_resize(border, (2 * WIDTH) / 3, (2 * HEIGHT) / 3); + evas_object_show(border); + + img = ecore_evas_object_image_new(ee); + evas_object_image_filled_set(img, EINA_TRUE); + evas_object_image_size_set( + img, ((2 * WIDTH) / 3) - 6, ((2 * HEIGHT) / 3) - 6); + sub_ee = ecore_evas_object_ecore_evas_get(img); + sub_canvas = ecore_evas_object_evas_get(img); + + evas_object_move(img, (WIDTH / 6) + 3, (HEIGHT / 6) + 3); + + /* apply the same size on both! */ + evas_object_resize(img, ((2 * WIDTH) / 3) - 6, ((2 * HEIGHT) / 3) - 6); + ecore_evas_resize(sub_ee, ((2 * WIDTH) / 3) - 6, ((2 * HEIGHT) / 3) - 6); + + r1 = evas_object_rectangle_add(sub_canvas); + evas_object_color_set(r1, 255, 0, 0, 255); /* 100% opaque red */ + evas_object_move(r1, 10, 10); + evas_object_resize(r1, 100, 100); + evas_object_show(r1); + + r2 = evas_object_rectangle_add(sub_canvas); + evas_object_color_set(r2, 0, 128, 0, 128); /* 50% opaque green */ + evas_object_move(r2, 10, 10); + evas_object_resize(r2, 50, 50); + evas_object_show(r2); + + r3 = evas_object_rectangle_add(sub_canvas); + evas_object_color_set(r3, 0, 128, 0, 255); /* 100% opaque dark green */ + evas_object_move(r3, 60, 60); + evas_object_resize(r3, 50, 50); + evas_object_show(r3); + + evas_object_show(img); + ecore_main_loop_begin(); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; + +error: + fprintf(stderr, "You got to have at least one Evas engine built" + " and linked up to ecore-evas for this example to run" + " properly.\n"); + ecore_evas_shutdown(); + return -1; +} + diff --git a/src/examples/ecore/ecore_evas_callbacks.c b/src/examples/ecore/ecore_evas_callbacks.c new file mode 100644 index 0000000000..3e42da161a --- /dev/null +++ b/src/examples/ecore/ecore_evas_callbacks.c @@ -0,0 +1,128 @@ +/** + * Ecore example illustrating ecore evas callbacks. + * + * You'll need at least one Evas engine built for it (excluding the + * buffer one). See stdout/stderr for output. + * + * @verbatim + * gcc -o ecore_evas_callbacks ecore_evas_callbacks.c `pkg-config --libs --cflags ecore-evas` + * @endverbatim + */ + +#include +#include + +static void +_destroy(Ecore_Evas *ee) +{ + printf("destroy\n"); + ecore_main_loop_quit(); +} + +static void +_delete(Ecore_Evas *ee) +{ + printf("delete\n"); + ecore_main_loop_quit(); +} + +static void +_focus_in(Ecore_Evas *ee) +{ + printf("focus_in\n"); +} + +static void +_focus_out(Ecore_Evas *ee) +{ + printf("focus_out\n"); +} + +static void +_hide(Ecore_Evas *ee) +{ + printf("hide\n"); +} + +static void +_mouse_in(Ecore_Evas *ee) +{ + printf("mouse_in\n"); +} + +static void +_show(Ecore_Evas *ee) +{ + printf("show\n"); +} + +static void +_mouse_out(Ecore_Evas *ee) +{ + printf("mouse_out\n"); +} + +static void +_move(Ecore_Evas *ee) +{ + printf("move\n"); +} + +static void +_post_render(Ecore_Evas *ee) +{ + printf("post_render\n"); +} + +static void +_pre_free(Ecore_Evas *ee) +{ + printf("pre_free\n"); +} + +static void +_pre_render(Ecore_Evas *ee) +{ + printf("pre_render\n"); +} + +static void +_resize(Ecore_Evas *ee) +{ + printf("resize\n"); +} + +int +main(void) +{ + Ecore_Evas *ee; + + ecore_evas_init(); + + ee = ecore_evas_new(NULL, 0, 0, 200, 100, NULL); + ecore_evas_title_set(ee, "Ecore Evas Callbacks Example"); + ecore_evas_show(ee); + + //callbacks + ecore_evas_callback_delete_request_set(ee, _delete); + ecore_evas_callback_destroy_set(ee, _destroy); + ecore_evas_callback_focus_in_set(ee, _focus_in); + ecore_evas_callback_focus_out_set(ee, _focus_out); + ecore_evas_callback_hide_set(ee, _hide); + ecore_evas_callback_mouse_in_set(ee, _mouse_in); + ecore_evas_callback_mouse_out_set(ee, _mouse_out); + ecore_evas_callback_move_set(ee, _move); + ecore_evas_callback_post_render_set(ee, _post_render); + ecore_evas_callback_pre_free_set(ee, _pre_free); + ecore_evas_callback_pre_render_set(ee, _pre_render); + ecore_evas_callback_resize_set(ee, _resize); + ecore_evas_callback_show_set(ee, _show); + + ecore_main_loop_begin(); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_evas_ews_example.c b/src/examples/ecore/ecore_evas_ews_example.c new file mode 100644 index 0000000000..1209ffd032 --- /dev/null +++ b/src/examples/ecore/ecore_evas_ews_example.c @@ -0,0 +1,269 @@ +/** + * Ecore example illustrating the ews of ecore evas usage. + * + * You'll need at least one Evas engine built for it (excluding the + * buffer one). See stdout/stderr for output. + * + * @verbatim + * gcc -o ecore_evas_ews_example ecore_evas_ews_example.c `pkg-config --libs --cflags ecore-evas` + * @endverbatim + */ + +#include +#include +#include +#include +#include + +static Eina_Bool +_wm_win_add(void *data, int type, void *event_info) +{ + Ecore_Evas *ee = event_info; + printf("WM: new window=%p\n", ee); + return EINA_TRUE; +} + +static Eina_Bool +_wm_win_move(void *data, int type, void *event_info) +{ + Ecore_Evas *ee = event_info; + int x, y; + ecore_evas_geometry_get(ee, &x, &y, NULL, NULL); + printf("WM: window=%p moved to %d,%d\n", ee, x, y); + return EINA_TRUE; +} + +static Eina_Bool +_wm_win_resize(void *data, int type, void *event_info) +{ + Ecore_Evas *ee = event_info; + int w, h; + ecore_evas_geometry_get(ee, NULL, NULL, &w, &h); + printf("WM: window=%p resized to %dx%d\n", ee, w, h); + return EINA_TRUE; +} + +static Eina_Bool +_wm_win_show(void *data, int type, void *event_info) +{ + Ecore_Evas *ee = event_info; + printf("WM: show window=%p\n", ee); + return EINA_TRUE; +} + +static void +optional_ews_window_manager_setup(void) +{ + ecore_event_handler_add(ECORE_EVAS_EWS_EVENT_ADD, _wm_win_add, NULL); + ecore_event_handler_add(ECORE_EVAS_EWS_EVENT_MOVE, _wm_win_move, NULL); + ecore_event_handler_add(ECORE_EVAS_EWS_EVENT_RESIZE, _wm_win_resize, NULL); + ecore_event_handler_add(ECORE_EVAS_EWS_EVENT_SHOW, _wm_win_show, NULL); + + /* one may use any known unique identifier, like an app function pointer */ + ecore_evas_ews_manager_set(optional_ews_window_manager_setup); +} + +static void +optional_ews_setup(void) +{ + Evas_Object *bg; + Evas *e; + + ecore_evas_ews_setup(0, 0, 800, 600); /* "screen" size */ + e = ecore_evas_ews_evas_get(); /* forces "screen" to be allocated */ + + bg = evas_object_rectangle_add(e); + evas_object_color_set(bg, 128, 32, 32, 255); + ecore_evas_ews_background_set(bg); +} + +static Eina_Bool +_stdin_cb(void *data, Ecore_Fd_Handler *handler) +{ + const Eina_List *l; + Ecore_Evas *ee; + char c = getchar(); + + if (c == EOF) + { + ecore_main_loop_quit(); + return EINA_FALSE; + } + + switch (c) { + case 'h': + printf("hide all windows\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_hide(ee); + break; + + case 's': + printf("show all windows\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_show(ee); + break; + + case 'l': + printf("move all windows left\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + { + int x, y; + ecore_evas_geometry_get(ee, &x, &y, NULL, NULL); + ecore_evas_move(ee, x - 10, y); + } + break; + + case 'r': + printf("move all windows right\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + { + int x, y; + ecore_evas_geometry_get(ee, &x, &y, NULL, NULL); + ecore_evas_move(ee, x + 10, y); + } + break; + + case 't': + printf("move all windows top\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + { + int x, y; + ecore_evas_geometry_get(ee, &x, &y, NULL, NULL); + ecore_evas_move(ee, x, y - 10); + } + break; + + case 'b': + printf("move all windows bottom\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + { + int x, y; + ecore_evas_geometry_get(ee, &x, &y, NULL, NULL); + ecore_evas_move(ee, x, y + 10); + } + break; + + case 'S': + printf("make all windows smaller\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + { + int w, h; + ecore_evas_geometry_get(ee, NULL, NULL, &w, &h); + ecore_evas_resize(ee, w - 10, h - 10); + } + break; + + case 'B': + printf("make all windows bigger\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + { + int w, h; + ecore_evas_geometry_get(ee, NULL, NULL, &w, &h); + ecore_evas_resize(ee, w + 10, h + 10); + } + break; + + case 'm': + printf("make all windows unmaximized\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_maximized_set(ee, EINA_FALSE); + break; + + case 'M': + printf("make all windows maximized\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_maximized_set(ee, EINA_TRUE); + break; + + case 'i': + printf("make all windows uniconified\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_iconified_set(ee, EINA_FALSE); + break; + + case 'I': + printf("make all windows iconified\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_iconified_set(ee, EINA_TRUE); + break; + + case 'f': + printf("make all windows unfullscreen\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_fullscreen_set(ee, EINA_FALSE); + break; + + case 'F': + printf("make all windows fullscreen\n"); + EINA_LIST_FOREACH(ecore_evas_ews_children_get(), l, ee) + ecore_evas_fullscreen_set(ee, EINA_TRUE); + break; + + case 'q': + printf("quit\n"); + ecore_main_loop_quit(); + break; + + default: + if (!isspace(c)) + printf("Unknown command: %c\n", c); + } + return ECORE_CALLBACK_RENEW; +} + +static void +_on_delete(Ecore_Evas *ee) +{ + free(ecore_evas_data_get(ee, "key")); + ecore_main_loop_quit(); +} + +int +main(void) +{ + Ecore_Evas *ee; + Evas *canvas; + Evas_Object *bg; + + if (ecore_evas_init() <= 0) + return 1; + + optional_ews_setup(); + optional_ews_window_manager_setup(); + + /* everything should look similar to ecore_evas_basic_example */ + ee = ecore_evas_ews_new(0, 0, 200, 200); + ecore_evas_title_set(ee, "Ecore Evas EWS Example"); + ecore_evas_show(ee); + + ecore_evas_data_set(ee, "key", strdup("hello")); + ecore_evas_callback_delete_request_set(ee, _on_delete); + + printf("Using %s engine!\n", ecore_evas_engine_name_get(ee)); + + canvas = ecore_evas_get(ee); + if (ecore_evas_ecore_evas_get(canvas) == ee) + printf("Everything is sane!\n"); + + bg = evas_object_rectangle_add(canvas); + evas_object_color_set(bg, 0, 0, 255, 255); + evas_object_resize(bg, 200, 200); + evas_object_show(bg); + ecore_evas_object_associate(ee, bg, ECORE_EVAS_OBJECT_ASSOCIATE_BASE); + + /* moving the window should move it in the screen */ + ecore_evas_move(ee, 50, 50); + + ecore_main_fd_handler_add(STDIN_FILENO, + ECORE_FD_READ | ECORE_FD_ERROR, + _stdin_cb, + NULL, NULL, NULL); + + ecore_main_loop_begin(); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_evas_object_example.c b/src/examples/ecore/ecore_evas_object_example.c new file mode 100644 index 0000000000..38e4c4b277 --- /dev/null +++ b/src/examples/ecore/ecore_evas_object_example.c @@ -0,0 +1,53 @@ +/** + * Ecore example illustrating ecore evas object usage. + * + * You'll need at least one Evas engine built for it (excluding the + * buffer one). See stdout/stderr for output. + * + * @verbatim + * gcc -o ecore_evas_object_example ecore_evas_object_example.c `pkg-config --libs --cflags ecore-evas` + * @endverbatim + */ + +#include +#include + +int +main(void) +{ + Ecore_Evas *ee; + Evas_Object *bg, *cursor, *obj; + int layer, x, y; + + ecore_evas_init(); + + ee = ecore_evas_new(NULL, 0, 0, 200, 200, NULL); + ecore_evas_title_set(ee, "Ecore Evas Object Example"); + ecore_evas_show(ee); + + bg = evas_object_rectangle_add(ecore_evas_get(ee)); + evas_object_color_set(bg, 0, 0, 255, 255); + evas_object_resize(bg, 200, 200); + evas_object_show(bg); + ecore_evas_object_associate(ee, bg, ECORE_EVAS_OBJECT_ASSOCIATE_BASE); + + if (bg == ecore_evas_object_associate_get(ee)) + printf("Association worked!\n"); + + cursor = evas_object_rectangle_add(ecore_evas_get(ee)); + evas_object_color_set(cursor, 0, 255, 0, 255); + evas_object_resize(cursor, 5, 10); + ecore_evas_object_cursor_set(ee, cursor, 0, 1, 1); + + ecore_evas_cursor_get(ee, &obj, &layer, &x, &y); + if (obj == cursor && layer == 0 && x == 1 && y == 1) + printf("Set cursor worked!\n"); + + ecore_main_loop_begin(); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_evas_window_sizes_example.c b/src/examples/ecore/ecore_evas_window_sizes_example.c new file mode 100644 index 0000000000..833529effc --- /dev/null +++ b/src/examples/ecore/ecore_evas_window_sizes_example.c @@ -0,0 +1,204 @@ +/** + * Simple @c Ecore_Evas example illustrating how to deal with window + * sizes + * + * You'll need at least one engine built for it (excluding the buffer + * one). See stdout/stderr for output. + * + * @verbatim + * gcc -o evas-smart-object evas-smart-object.c `pkg-config --libs --cflags evas ecore ecore-evas` + * @endverbatim + */ + +#ifdef HAVE_CONFIG_H + +#include "config.h" +#else +#define EINA_UNUSED +#endif + +#include +#include + +#define WIDTH (300) +#define HEIGHT (300) + +static Ecore_Evas *ee; +static Evas_Object *text, *bg; +static Eina_Bool min_set = EINA_FALSE; +static Eina_Bool max_set = EINA_FALSE; +static Eina_Bool base_set = EINA_FALSE; +static Eina_Bool step_set = EINA_FALSE; + +static const char commands[] = \ + "commands are:\n" + "\tm - impose a minumum size to the window\n" + "\tx - impose a maximum size to the window\n" + "\tb - impose a base size to the window\n" + "\ts - impose a step size (different than 1 px) to the window\n" + "\th - print help\n"; + +/* to inform current window's size */ +static void +_canvas_resize_cb(Ecore_Evas *ee) +{ + int w, h; + char buf[1024]; + + ecore_evas_geometry_get(ee, NULL, NULL, &w, &h); + snprintf(buf, sizeof(buf), "%d x %d", w, h); + evas_object_text_text_set(text, buf); + evas_object_move(text, (w - 150) / 2, (h - 50) / 2); + + evas_object_resize(bg, w, h); +} + +static void +_on_destroy(Ecore_Evas *ee EINA_UNUSED) +{ + ecore_main_loop_quit(); +} + +static void +_on_keydown(void *data EINA_UNUSED, + Evas *evas EINA_UNUSED, + Evas_Object *o EINA_UNUSED, + void *einfo) +{ + Evas_Event_Key_Down *ev = einfo; + + if (strcmp(ev->keyname, "h") == 0) /* print help */ + { + fprintf(stdout, commands); + return; + } + + if (strcmp(ev->keyname, "m") == 0) /* impose a minimum size on the window */ + { + min_set = !min_set; + + if (min_set) + { + ecore_evas_size_min_set(ee, WIDTH / 2, HEIGHT / 2); + fprintf(stdout, "Imposing a minimum size of %d x %d\n", + WIDTH / 2, HEIGHT / 2); + } + else + { + ecore_evas_size_min_set(ee, 0, 0); + fprintf(stdout, "Taking off minimum size restriction from the" + " window\n"); + } + return; + } + + if (strcmp(ev->keyname, "x") == 0) /* impose a maximum size on the window */ + { + max_set = !max_set; + + if (max_set) + { + ecore_evas_size_max_set(ee, WIDTH * 2, HEIGHT * 2); + fprintf(stdout, "Imposing a maximum size of %d x %d\n", + WIDTH * 2, HEIGHT * 2); + } + else + { + ecore_evas_size_max_set(ee, 0, 0); + fprintf(stdout, "Taking off maximum size restriction from the" + " window\n"); + } + return; + } + + if (strcmp(ev->keyname, "b") == 0) /* impose a base size on the window */ + { + base_set = !base_set; + + if (base_set) + { + ecore_evas_size_base_set(ee, WIDTH * 2, HEIGHT * 2); + fprintf(stdout, "Imposing a base size of %d x %d\n", + WIDTH * 2, HEIGHT * 2); + } + else + { + ecore_evas_size_base_set(ee, 0, 0); + fprintf(stdout, "Taking off base size restriction from the" + " window\n"); + } + return; + } + + if (strcmp(ev->keyname, "s") == 0) /* impose a step size on the window */ + { + step_set = !step_set; + + if (step_set) + { + ecore_evas_size_step_set(ee, 40, 40); + fprintf(stdout, "Imposing a step size of %d x %d\n", 40, 40); + } + else + { + ecore_evas_size_step_set(ee, 0, 0); + fprintf(stdout, "Taking off step size restriction from the" + " window\n"); + } + return; + } +} + +int +main(void) +{ + Evas *evas; + + if (!ecore_evas_init()) + return EXIT_FAILURE; + + /* this will give you a window with an Evas canvas under the first + * engine available */ + ee = ecore_evas_new(NULL, 0, 0, WIDTH, HEIGHT, NULL); + if (!ee) goto error; + + ecore_evas_callback_delete_request_set(ee, _on_destroy); + ecore_evas_title_set(ee, "Ecore_Evas window sizes example"); + ecore_evas_callback_resize_set(ee, _canvas_resize_cb); + ecore_evas_show(ee); + + evas = ecore_evas_get(ee); + + bg = evas_object_rectangle_add(evas); + evas_object_color_set(bg, 255, 255, 255, 255); /* white bg */ + evas_object_move(bg, 0, 0); /* at canvas' origin */ + evas_object_resize(bg, WIDTH, HEIGHT); /* covers full canvas */ + evas_object_show(bg); + + evas_object_focus_set(bg, EINA_TRUE); + evas_object_event_callback_add( + bg, EVAS_CALLBACK_KEY_DOWN, _on_keydown, NULL); + + text = evas_object_text_add(evas); + evas_object_color_set(text, 0, 0, 0, 255); + evas_object_resize(text, 150, 50); + evas_object_text_font_set(text, "Sans", 20); + evas_object_show(text); + + _canvas_resize_cb(ee); + fprintf(stdout, commands); + ecore_main_loop_begin(); + + ecore_evas_free(ee); + ecore_evas_shutdown(); + + return 0; + +error: + fprintf(stderr, "You got to have at least one Evas engine built" + " and linked up to ecore-evas for this example to run" + " properly.\n"); + ecore_evas_shutdown(); + return -1; +} + diff --git a/src/examples/ecore/ecore_event_example_01.c b/src/examples/ecore/ecore_event_example_01.c new file mode 100644 index 0000000000..64a5be8650 --- /dev/null +++ b/src/examples/ecore/ecore_event_example_01.c @@ -0,0 +1,26 @@ +/* + * Compile with: + * gcc -g -Wall `pkg-config --cflags --libs ecore` -o ecore_event_example ecore_event_example.c + */ + +#include + +static Eina_Bool +_quitter(void *data, int ev_type, void *event) +{ + printf("Leaving already?\n"); + ecore_main_loop_quit(); + return ECORE_CALLBACK_DONE; +} + +int +main(int argc, char **argv) +{ + ecore_init(); + + ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _quitter, NULL); + ecore_main_loop_begin(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_event_example_02.c b/src/examples/ecore/ecore_event_example_02.c new file mode 100644 index 0000000000..c293e65453 --- /dev/null +++ b/src/examples/ecore/ecore_event_example_02.c @@ -0,0 +1,89 @@ +#include +#include + +struct context // helper struct to give some context to the callbacks +{ + const char *str1, *str2; + Ecore_Event_Handler *handler1; + Ecore_Event_Handler *handler2; +}; + +static int _event_type = 0; // a new type of event will be defined and stored here + +static Eina_Bool +_event_handler1_cb(void *data, int type, void *event) +{ + int *number = event; + const char *str = data; + + printf("event_handler1: number=%d, data=\"%s\".\n", *number, str); + + if ((*number % 2) == 0) + return ECORE_CALLBACK_DONE; + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_event_handler2_cb(void *data, int type, void *event) // event callback +{ + struct context *ctxt = data; + int *number = event; + + printf("event_handler2: number=%d.\n", *number); + + if (*number == 5) + { + const char *old = NULL; + old = ecore_event_handler_data_set(ctxt->handler1, (void *)ctxt->str2); + printf("changed handler1 data from \"%s\" to \"%s\".\n", + old, ctxt->str2); + } + else if (*number >= 10) + { + printf("finish main loop.\n"); + ecore_main_loop_quit(); + } + + return ECORE_CALLBACK_DONE; // same as EINA_FALSE +} + +int +main(int argc, char **argv) +{ + struct context ctxt = {0}; + int i; + ctxt.str1 = "dataone"; + ctxt.str2 = "datatwo"; + + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + _event_type = ecore_event_type_new(); + + ctxt.handler1 = ecore_event_handler_add(_event_type, + _event_handler1_cb, + ctxt.str1); + ctxt.handler2 = ecore_event_handler_add(_event_type, + _event_handler2_cb, + &ctxt); + + for (i = 0; i <= 15; i++) + { + int *event_data = malloc(sizeof(*event_data)); + *event_data = i; + ecore_event_add(_event_type, event_data, NULL, NULL); + } + + printf("start the main loop.\n"); + + ecore_main_loop_begin(); + + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_exe_example.c b/src/examples/ecore/ecore_exe_example.c new file mode 100644 index 0000000000..8d0dedc846 --- /dev/null +++ b/src/examples/ecore/ecore_exe_example.c @@ -0,0 +1,100 @@ +/** + Compile with gcc -o ecore_exe_example ecore_exe_example.c `pkg-config --cflags --libs ecore` + */ + +#include +#include +#include + +#define BUFFER_SIZE 1024 + +static Eina_Bool +_msg_from_child_handler(void *data, int type, void *event) +{ + Ecore_Exe_Event_Data *dataFromProcess = (Ecore_Exe_Event_Data *)event; + char msg[BUFFER_SIZE]; + + if (dataFromProcess->size >= (BUFFER_SIZE - 1)) + { + fprintf(stdout, "Data too big for bugger. error\n"); + return ECORE_CALLBACK_DONE; + } + + strncpy(msg, dataFromProcess->data, dataFromProcess->size); + msg[dataFromProcess->size] = 0; + + if (strcmp(msg, "quit") == 0) + { + fprintf(stdout, "My child said to me, QUIT!\n"); + ecore_main_loop_quit(); + } + else + fprintf(stdout, "I received a message from my child: %s\n", msg); + + return ECORE_CALLBACK_DONE; +} + +static Eina_Bool +_sendMessage(void *data) +{ + static int numberOfMessages = 0; + Ecore_Exe *childHandle = (Ecore_Exe *)data; + char msg[BUFFER_SIZE]; + + sprintf(msg, " Message: %d\n", numberOfMessages); + numberOfMessages++; + + if (ecore_exe_send(childHandle, msg, strlen(msg)) != EINA_TRUE) + fprintf(stderr, "Could not send my name to the child\n"); + else + fprintf(stdout, + "I'm the father and I sent this message to the child: %s\n", msg); + + return ECORE_CALLBACK_RENEW; +} + +int +main(int argc, char **argv) +{ + pid_t childPid; + Ecore_Exe *childHandle; + + if (!ecore_init()) + goto exit; + + childHandle = ecore_exe_pipe_run("./ecore_exe_example_child", + ECORE_EXE_PIPE_WRITE | + ECORE_EXE_PIPE_READ_LINE_BUFFERED | + ECORE_EXE_PIPE_READ, NULL); + + if (childHandle == NULL) + { + fprintf(stderr, "Could not create a child process!\n"); + goto ecore_shutdown; + } + + childPid = ecore_exe_pid_get(childHandle); + + if (childPid == -1) + fprintf(stderr, "Could not retrive the PID!\n"); + else + fprintf(stdout, "The child process has PID:%d\n", childPid); + + ecore_event_handler_add(ECORE_EXE_EVENT_DATA, _msg_from_child_handler, NULL); + ecore_timer_add(1, _sendMessage, childHandle); + + ecore_main_loop_begin(); + + ecore_exe_free(childHandle); //This will not affect the child process + + ecore_shutdown(); + + return EXIT_SUCCESS; + +ecore_shutdown: + ecore_shutdown(); + +exit: + return EXIT_FAILURE; +} + diff --git a/src/examples/ecore/ecore_exe_example_child.c b/src/examples/ecore/ecore_exe_example_child.c new file mode 100644 index 0000000000..efe97fb111 --- /dev/null +++ b/src/examples/ecore/ecore_exe_example_child.c @@ -0,0 +1,57 @@ +/** + Compile with gcc -o ecore_exe_example_child ecore_exe_example_child.c `pkg-config --cflags --libs ecore` + */ + +#include +#include +#include + +#define BUFFER_SIZE 1024 + +static Eina_Bool +_fd_handler_cb(void *data, Ecore_Fd_Handler + *fd_handler) +{ + static int numberOfMessages = 0; + char message[BUFFER_SIZE]; + + if (!fgets(message, BUFFER_SIZE, stdin)) + return ECORE_CALLBACK_RENEW; + + numberOfMessages++; + + if (numberOfMessages < 3) + { + fprintf(stdout, "My father sent this message to me:%s\n", message); + fflush(stdout); + return ECORE_CALLBACK_RENEW; + } + else + { + fprintf(stdout, "quit\n"); + fflush(stdout); + ecore_main_loop_quit(); + return ECORE_CALLBACK_DONE; + } +} + +int +main(int argc, char **argv) +{ + if (!ecore_init()) + goto error; + + ecore_main_fd_handler_add(STDIN_FILENO, + ECORE_FD_READ, + _fd_handler_cb, + NULL, NULL, NULL); + ecore_main_loop_begin(); + + ecore_shutdown(); + + return EXIT_SUCCESS; + +error: + return EXIT_FAILURE; +} + diff --git a/src/examples/ecore/ecore_fd_handler_example.c b/src/examples/ecore/ecore_fd_handler_example.c new file mode 100644 index 0000000000..381d1014e7 --- /dev/null +++ b/src/examples/ecore/ecore_fd_handler_example.c @@ -0,0 +1,89 @@ +#include +#include + +struct context +{ + Ecore_Fd_Handler *handler; + Ecore_Timer *timer; +}; + +static void +_fd_prepare_cb(void *data, Ecore_Fd_Handler *handler) +{ + printf("prepare_cb called.\n"); +} + +static Eina_Bool +_fd_handler_cb(void *data, Ecore_Fd_Handler *handler) +{ + struct context *ctxt = data; + char buf[1024]; + size_t nbytes; + int fd; + + if (ecore_main_fd_handler_active_get(handler, ECORE_FD_ERROR)) + { + printf("An error has occurred. Stop watching this fd and quit.\n"); + ecore_main_loop_quit(); + ctxt->handler = NULL; + return ECORE_CALLBACK_CANCEL; + } + + fd = ecore_main_fd_handler_fd_get(handler); + nbytes = read(fd, buf, sizeof(buf)); + if (nbytes == 0) + { + printf("Nothing to read, exiting...\n"); + ecore_main_loop_quit(); + ctxt->handler = NULL; + return ECORE_CALLBACK_CANCEL; + } + buf[nbytes - 1] = '\0'; + + printf("Read %zd bytes from input: \"%s\"\n", nbytes - 1, buf); + + return ECORE_CALLBACK_RENEW; +} + +static Eina_Bool +_timer_cb(void *data) +{ + printf("Timer expired after 5 seconds...\n"); + + return ECORE_CALLBACK_RENEW; +} + +int +main(int argc, char **argv) +{ + struct context ctxt = {0}; + + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + ctxt.handler = ecore_main_fd_handler_add(STDIN_FILENO, + ECORE_FD_READ | ECORE_FD_ERROR, + _fd_handler_cb, + &ctxt, NULL, NULL); + ecore_main_fd_handler_prepare_callback_set(ctxt.handler, _fd_prepare_cb, &ctxt); + ctxt.timer = ecore_timer_add(5, _timer_cb, &ctxt); + + printf("Starting the main loop. Type anything and hit to " + "activate the fd_handler callback, or CTRL+d to shutdown.\n"); + + ecore_main_loop_begin(); + + if (ctxt.handler) + ecore_main_fd_handler_del(ctxt.handler); + + if (ctxt.timer) + ecore_timer_del(ctxt.timer); + + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_fd_handler_gnutls_example.c b/src/examples/ecore/ecore_fd_handler_gnutls_example.c new file mode 100644 index 0000000000..5635b131cc --- /dev/null +++ b/src/examples/ecore/ecore_fd_handler_gnutls_example.c @@ -0,0 +1,203 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Ecore_Fd_Handler example + * 2010 Mike Blumenkrantz + * compile with gcc $(pkgconfig --cflags --libs gnutls ecore) + */ + +#define print(...) fprintf(stderr, "line %i: ", __LINE__); fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n") + +static int done = 0; + +static void +tls_log_func(int level, const char *str) +{ + fprintf(stderr, "|<%d>| %s", level, str); +} + +static const char * +SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_description_t status) +{ + switch (status) + { + case GNUTLS_HANDSHAKE_HELLO_REQUEST: + return "Hello request"; + + case GNUTLS_HANDSHAKE_CLIENT_HELLO: + return "Client hello"; + + case GNUTLS_HANDSHAKE_SERVER_HELLO: + return "Server hello"; + + case GNUTLS_HANDSHAKE_CERTIFICATE_PKT: + return "Certificate packet"; + + case GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE: + return "Server key exchange"; + + case GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST: + return "Certificate request"; + + case GNUTLS_HANDSHAKE_SERVER_HELLO_DONE: + return "Server hello done"; + + case GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY: + return "Certificate verify"; + + case GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE: + return "Client key exchange"; + + case GNUTLS_HANDSHAKE_FINISHED: + return "Finished"; + + case GNUTLS_HANDSHAKE_SUPPLEMENTAL: + return "Supplemental"; + } + return NULL; +} + +/* Connects to the peer and returns a socket + * descriptor. + */ +static int +tcp_connect(void) +{ + const char *PORT = "443"; + const char *SERVER = "69.58.181.89"; //verisign.com + int err, sd; + int flag = 1, curstate = 0; + struct sockaddr_in sa; + + /* sets some fd options such as nonblock */ + sd = socket(AF_INET, SOCK_STREAM, 0); + fcntl(sd, F_SETFL, O_NONBLOCK); + fcntl(sd, F_SETFD, FD_CLOEXEC); + setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (const void *)&curstate, sizeof(curstate)); + + setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(int)); + + memset(&sa, '\0', sizeof (sa)); + sa.sin_family = AF_INET; + sa.sin_port = htons(atoi(PORT)); + inet_pton(AF_INET, SERVER, &sa.sin_addr); + + /* connects to server + */ + err = connect(sd, (struct sockaddr *)&sa, sizeof (sa)); + if ((err < 0) && (errno != EINPROGRESS)) + { + print("Connect error\n"); + exit(1); + } + + return sd; +} + +/* closes the given socket descriptor. + */ +static void +tcp_close(int sd) +{ + shutdown(sd, SHUT_RDWR); /* no more receptions */ + close(sd); +} + +static Eina_Bool +_process_data(gnutls_session_t client, Ecore_Fd_Handler *fd_handler) +{ + static int ret, lastret; + static unsigned int count = 0; + + if (!done) + { + lastret = ret; + ret = gnutls_handshake(client); + count++; + if (gnutls_record_get_direction(client)) + ecore_main_fd_handler_active_set(fd_handler, ECORE_FD_WRITE); + else + ecore_main_fd_handler_active_set(fd_handler, ECORE_FD_READ); + /* avoid printing messages infinity times */ + if (lastret != ret) + { + print("gnutls returned with: %s - %s", gnutls_strerror_name(ret), gnutls_strerror(ret)); + if ((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) || (ret == GNUTLS_E_FATAL_ALERT_RECEIVED)) + print("Also received alert: %s", gnutls_alert_get_name(gnutls_alert_get(client))); + print("last out: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_out(client))); + print("last in: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_in(client))); + } + + if (gnutls_error_is_fatal(ret)) + { + print("yarrr this be an error!"); + exit(1); + } + } + if (ret == GNUTLS_E_SUCCESS) + { + done = 1; + print("Handshake successful in %u handshake calls!", count); + ecore_main_loop_quit(); + } + + return ECORE_CALLBACK_RENEW; +} + +int +main(void) +{ + /* credentials */ + gnutls_anon_client_credentials_t c_anoncred; + gnutls_certificate_credentials_t c_certcred; + + gnutls_session_t client; + int sd; + + /* General init. */ + gnutls_global_init(); + ecore_init(); + gnutls_global_set_log_function(tls_log_func); + gnutls_global_set_log_level(6); + + /* Init client */ + gnutls_anon_allocate_client_credentials(&c_anoncred); + gnutls_certificate_allocate_credentials(&c_certcred); + gnutls_init(&client, GNUTLS_CLIENT); + /* set very specific priorities */ + gnutls_priority_set_direct(client, "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:+VERS-TLS1.2:+VERS-TLS1.1:+VERS-TLS1.0:+VERS-SSL3.0", NULL); + gnutls_credentials_set(client, GNUTLS_CRD_ANON, c_anoncred); + gnutls_credentials_set(client, GNUTLS_CRD_CERTIFICATE, c_certcred); + gnutls_server_name_set(client, GNUTLS_NAME_DNS, "www.verisign.com", strlen("www.verisign.com")); + + /* connect to the peer + */ + sd = tcp_connect(); + + /* associate gnutls with socket */ + gnutls_transport_set_ptr(client, (gnutls_transport_ptr_t)sd); + /* add a callback for data being available for send/receive on socket */ + if (!ecore_main_fd_handler_add(sd, ECORE_FD_READ | ECORE_FD_WRITE, (Ecore_Fd_Cb)_process_data, client, NULL, NULL)) + { + print("could not create fd handler!"); + exit(1); + } + /* begin main loop */ + ecore_main_loop_begin(); + + gnutls_bye(client, GNUTLS_SHUT_RDWR); + + gnutls_deinit(client); + + tcp_close(sd); + + return 0; +} + diff --git a/src/examples/ecore/ecore_file_download_example.c b/src/examples/ecore/ecore_file_download_example.c new file mode 100644 index 0000000000..42cff6c32d --- /dev/null +++ b/src/examples/ecore/ecore_file_download_example.c @@ -0,0 +1,86 @@ +#include +#include +#include +#include + +/* + * ecore_file_download() example + * + * compile with: + * gcc ecore_file_download_example.c `pkg-config --libs --cflags ecore-file` \ + * -o ecore_file_download_example + * + */ + +#define URL "http://www.kernel.org/pub/linux/kernel/v1.0/linux-1.0.tar.gz" +#define DST "linux-1.0.tar.gz" +#define DST_MIME "[x-gzip]linux-1.0.tar.gz" + +void +completion_cb(void *data, const char *file, int status) +{ + printf("Done (status: %d)\n", status); + ecore_main_loop_quit(); +} + +int +progress_cb(void *data, const char *file, + long int dltotal, long int dlnow, + long int ultotal, long int ulnow) +{ + printf("Progress: %ld/%ld\n", dlnow, dltotal); + return ECORE_FILE_PROGRESS_CONTINUE; // continue the download +} + +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; +} + diff --git a/src/examples/ecore/ecore_idler_example.c b/src/examples/ecore/ecore_idler_example.c new file mode 100644 index 0000000000..9db99cd6d4 --- /dev/null +++ b/src/examples/ecore/ecore_idler_example.c @@ -0,0 +1,117 @@ +#include +#include + +struct context // helper struct to give some context to the callbacks +{ + int count; + Ecore_Idle_Enterer *enterer; + Ecore_Idler *idler; + Ecore_Idle_Exiter *exiter; + Ecore_Event_Handler *handler; + Ecore_Timer *timer; +}; + +static int _event_type = 0; // a new type of event will be defined and stored here + +static Eina_Bool +_enterer_cb(void *data) // the idle enterer callback +{ + printf("IDLE ENTERER: Ecore entering in idle state.\n"); + + return ECORE_CALLBACK_RENEW; // same as EINA_TRUE +} + +static Eina_Bool +_exiter_cb(void *data) // the idle exiter callback +{ + printf("IDLE EXITER: Ecore exiting idle state.\n"); + + return ECORE_CALLBACK_RENEW; // same as EINA_TRUE +} + +static Eina_Bool +_idler_cb(void *data) // the idler callback - ran while the mainloop is idle +{ + struct context *ctxt = data; + printf("IDLER: executing idler callback while in idle state.\n"); + + ctxt->count++; + + /* each 10 times that the callback gets called, generate an event that + * will wake up the main loop, triggering idle enterers, exiters, etc. */ + if ((ctxt->count % 10) == 0) + ecore_event_add(_event_type, NULL, NULL, NULL); + + return ECORE_CALLBACK_RENEW; // same as EINA_TRUE +} + +static Eina_Bool +_event_handler_cb(void *data, int type, void *event) // event callback +{ + struct context *ctxt = data; + + printf("EVENT: processing callback for the event received.\n"); + + if (ctxt->count > 100) + { + ecore_idle_enterer_del(ctxt->enterer); + ecore_idle_exiter_del(ctxt->exiter); +// ecore_idler_del(ctxt->idler); + eo_unref(ctxt->idler); + + ctxt->enterer = NULL; + ctxt->exiter = NULL; + ctxt->idler = NULL; + + if (ctxt->timer) + { + ecore_timer_del(ctxt->timer); + ctxt->timer = NULL; + } + + ecore_main_loop_quit(); + } + + return ECORE_CALLBACK_DONE; // same as EINA_FALSE +} + +static Eina_Bool +_timer_cb(void *data) +{ + struct context *ctxt = data; + printf("TIMER: timer callback called.\n"); + + if (ctxt->timer) + ctxt->timer = NULL; + + return ECORE_CALLBACK_CANCEL; // same as EINA_FALSE +} + +int +main(int argc, char **argv) +{ + struct context ctxt = {0}; + + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + _event_type = ecore_event_type_new(); + + ctxt.enterer = ecore_idle_enterer_add(_enterer_cb, &ctxt); + ctxt.exiter = ecore_idle_exiter_add(_exiter_cb, &ctxt); +// ctxt.idler = ecore_idler_add(_idler_cb, &ctxt); + ctxt.idler = eo_add_custom(ECORE_IDLER_CLASS, NULL, ecore_idler_constructor(_idler_cb, &ctxt)); + ctxt.handler = ecore_event_handler_add(_event_type, + _event_handler_cb, + &ctxt); + ctxt.timer = ecore_timer_add(0.0005, _timer_cb, &ctxt); + + ecore_main_loop_begin(); + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_imf_example.c b/src/examples/ecore/ecore_imf_example.c new file mode 100644 index 0000000000..0ca080e3b5 --- /dev/null +++ b/src/examples/ecore/ecore_imf_example.c @@ -0,0 +1,588 @@ +/** + * Ecore example illustrating how to use ecore imf. + * + * @verbatim + * gcc -o ecore_imf_example ecore_imf_example.c `pkg-config --cflags --libs ecore evas ecore-evas ecore-imf ecore-imf-evas` + * @endverbatim + */ + +#include +#include +#include +#include +#include +#include + +typedef struct _Entry Entry; + +struct _Entry +{ + Evas_Object *rect; + Evas_Object *txt_obj; + Evas_Textblock_Style *txt_style; + Evas_Textblock_Cursor *cursor; + Evas_Textblock_Cursor *preedit_start; + Evas_Textblock_Cursor *preedit_end; + Ecore_IMF_Context *imf_context; + Eina_Bool have_preedit : 1; +}; + +static void +_mouse_up_cb(void *data, Evas *e, Evas_Object *o, void *event_info) +{ + Entry *en = data; + if (!en) return; + + if (en->imf_context) + ecore_imf_context_reset(en->imf_context); + + evas_object_focus_set(en->rect, EINA_TRUE); +} + +static void +_entry_focus_in_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Entry *en = data; + if (!en) return; + + if (en->imf_context) + ecore_imf_context_focus_in(en->imf_context); +} + +static void +_entry_focus_out_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Entry *en = data; + if (!en) return; + + if (en->imf_context) + { + ecore_imf_context_reset(en->imf_context); + ecore_imf_context_focus_out(en->imf_context); + } +} + +static void +_canvas_focus_in_cb(void *data, Evas *e, void *event_info) +{ + Entry *en; + Evas_Object *obj = evas_focus_get(e); + if (!obj) return; + + en = evas_object_data_get(obj, "Entry"); + if (en) + _entry_focus_in_cb(en, NULL, NULL, NULL); +} + +static void +_canvas_focus_out_cb(void *data, Evas *e, void *event_info) +{ + Entry *en; + Evas_Object *obj = evas_focus_get(e); + if (!obj) return; + + en = evas_object_data_get(obj, "Entry"); + if (en) + _entry_focus_out_cb(en, NULL, NULL, NULL); +} + +static void +_imf_cursor_info_set(Entry *en) +{ + Evas_Coord x, y, w, h; + Evas_Coord cx, cy, cw, ch; // cursor geometry + int cursor_pos; // cursor position in chars (Not bytes) + + if (!en) return; + + // get cursor geometry + evas_object_geometry_get(en->txt_obj, &x, &y, &w, &h); + evas_textblock_cursor_geometry_get(en->cursor, &cx, &cy, &cw, &ch, NULL, EVAS_TEXTBLOCK_CURSOR_BEFORE); + + // get cursor position + cursor_pos = evas_textblock_cursor_pos_get(en->cursor); + + ecore_imf_context_cursor_position_set(en->imf_context, cursor_pos); + ecore_imf_context_cursor_location_set(en->imf_context, x + cx, y + cy, cw, ch); +} + +static void +_preedit_del(Entry *en) +{ + if (!en || !en->have_preedit) return; + if (!en->preedit_start || !en->preedit_end) return; + if (!evas_textblock_cursor_compare(en->preedit_start, en->preedit_end)) return; + + /* delete the preedit characters */ + evas_textblock_cursor_range_delete(en->preedit_start, en->preedit_end); +} + +static void +_preedit_clear(Entry *en) +{ + if (en->preedit_start) + { + evas_textblock_cursor_free(en->preedit_start); + en->preedit_start = NULL; + } + + if (en->preedit_end) + { + evas_textblock_cursor_free(en->preedit_end); + en->preedit_end = NULL; + } + + en->have_preedit = EINA_FALSE; +} + +static Eina_Bool +_ecore_imf_retrieve_surrounding_cb(void *data, Ecore_IMF_Context *ctx, char **text, int *cursor_pos) +{ + /* This callback will be called when the Input Method Context module requests the surrounding context. */ + Entry *en = data; + const char *str; + + if (!en) return; + + str = evas_object_textblock_text_markup_get(en->txt_obj); + + if (text) + *text = str ? strdup(str) : strdup(""); + + /* get the current position of cursor */ + if (cursor_pos) + *cursor_pos = evas_textblock_cursor_pos_get(en->cursor); + + return EINA_TRUE; +} + +static void +_ecore_imf_event_delete_surrounding_cb(void *data, Ecore_IMF_Context *ctx, void *event_info) +{ + /* called when the input method needs to delete all or part of the context surrounding the cursor */ + Entry *en = data; + Ecore_IMF_Event_Delete_Surrounding *ev = event_info; + Evas_Textblock_Cursor *del_start, *del_end; + int cursor_pos; + + if (!en) return; + + cursor_pos = evas_textblock_cursor_pos_get(en->cursor); + + del_start = evas_object_textblock_cursor_new(en->txt_obj); + evas_textblock_cursor_pos_set(del_start, cursor_pos + ev->offset); + + del_end = evas_object_textblock_cursor_new(en->txt_obj); + evas_textblock_cursor_pos_set(del_end, cursor_pos + ev->offset + ev->n_chars); + + /* implement function to delete character(s) from 'cursor_pos+ev->offset' cursor position to 'cursor_pos + ev->offset + ev->n_chars' */ + evas_textblock_cursor_range_delete(del_start, del_end); + + evas_textblock_cursor_free(del_start); + evas_textblock_cursor_free(del_end); +} + +static void +_ecore_imf_event_commit_cb(void *data, Ecore_IMF_Context *ctx, void *event_info) +{ + Entry *en = data; + char *commit_str = (char *)event_info; + if (!en) return; + + /* delete preedit string */ + _preedit_del(en); + _preedit_clear(en); + + printf("commit string : %s\n", commit_str); + + evas_object_textblock_text_markup_prepend(en->cursor, commit_str); + + /* notify cursor information */ + _imf_cursor_info_set(en); + + return; +} + +static void +_ecore_imf_event_preedit_changed_cb(void *data, Ecore_IMF_Context *ctx, void *event_info) +{ + /* example how to get preedit string */ + Entry *en = data; + char *preedit_string; + int cursor_pos; + Eina_List *attrs = NULL; + Eina_List *l; + Ecore_IMF_Preedit_Attr *attr; + Ecore_IMF_Context *imf_context = ctx; + int preedit_start_pos, preedit_end_pos; + int i; + Eina_Bool preedit_end_state = EINA_FALSE; + + if (!en) return; + + /* get preedit string, attributes */ + ecore_imf_context_preedit_string_with_attributes_get(imf_context, &preedit_string, &attrs, &cursor_pos); + printf("preedit string : %s\n", preedit_string); + + if (!strcmp(preedit_string, "")) + preedit_end_state = EINA_TRUE; + + /* delete preedit */ + _preedit_del(en); + + preedit_start_pos = evas_textblock_cursor_pos_get(en->cursor); + + /* insert preedit character(s) */ + if (strlen(preedit_string) > 0) + { + if (attrs) + { + EINA_LIST_FOREACH(attrs, l, attr) + { + if (attr->preedit_type == ECORE_IMF_PREEDIT_TYPE_SUB1) // style type + { + /* apply appropriate style such as underline */ + } + else if (attr->preedit_type == ECORE_IMF_PREEDIT_TYPE_SUB2 || attr->preedit_type == ECORE_IMF_PREEDIT_TYPE_SUB3) + { + /* apply appropriate style such as underline */ + } + } + + /* insert code to display preedit string in your editor */ + evas_object_textblock_text_markup_prepend(en->cursor, preedit_string); + } + } + + if (!preedit_end_state) + { + /* set preedit start cursor */ + if (!en->preedit_start) + en->preedit_start = evas_object_textblock_cursor_new(en->txt_obj); + evas_textblock_cursor_copy(en->cursor, en->preedit_start); + + /* set preedit end cursor */ + if (!en->preedit_end) + en->preedit_end = evas_object_textblock_cursor_new(en->txt_obj); + evas_textblock_cursor_copy(en->cursor, en->preedit_end); + + preedit_end_pos = evas_textblock_cursor_pos_get(en->cursor); + + for (i = 0; i < (preedit_end_pos - preedit_start_pos); i++) + { + evas_textblock_cursor_char_prev(en->preedit_start); + } + + en->have_preedit = EINA_TRUE; + + /* set cursor position */ + evas_textblock_cursor_pos_set(en->cursor, preedit_start_pos + cursor_pos); + } + + /* notify cursor information */ + _imf_cursor_info_set(en); + + EINA_LIST_FREE(attrs, attr) + free(attr); + + free(preedit_string); +} + +static void +_key_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Entry *en = data; + Evas_Event_Key_Down *ev = event_info; + Eina_Bool control, alt, shift; + Eina_Bool multiline; + Eina_Bool cursor_changed; + if (!en) return; + if (!ev->key) return; + + if (en->imf_context) + { + Ecore_IMF_Event_Key_Down ecore_ev; + ecore_imf_evas_event_key_down_wrap(ev, &ecore_ev); + if (ecore_imf_context_filter_event(en->imf_context, + ECORE_IMF_EVENT_KEY_DOWN, + (Ecore_IMF_Event *)&ecore_ev)) + return; + } + + control = evas_key_modifier_is_set(ev->modifiers, "Control"); + alt = evas_key_modifier_is_set(ev->modifiers, "Alt"); + shift = evas_key_modifier_is_set(ev->modifiers, "Shift"); + + if ((!strcmp(ev->keyname, "Escape")) || + (!strcmp(ev->keyname, "Return")) || (!strcmp(ev->keyname, "KP_Enter"))) + ecore_imf_context_reset(en->imf_context); + + if (!strcmp(ev->key, "BackSpace")) + { + if (evas_textblock_cursor_char_prev(en->cursor)) + { + evas_textblock_cursor_char_delete(en->cursor); + /* notify cursor information */ + _imf_cursor_info_set(en); + } + return; + } + else if (!strcmp(ev->key, "Delete") || + (!strcmp(ev->key, "KP_Delete") && !ev->string)) + { + // FILLME + } + else if ((control) && (!strcmp(ev->key, "v"))) + { + // ctrl + v + // FILLME + } + else if ((control) && (!strcmp(ev->key, "a"))) + { + // ctrl + a + // FILLME + } + else if ((control) && (!strcmp(ev->key, "A"))) + { + // ctrl + A + // FILLME + } + else if ((control) && ((!strcmp(ev->key, "c") || (!strcmp(ev->key, "Insert"))))) + { + // ctrl + c + // FILLME + } + else if ((control) && ((!strcmp(ev->key, "x") || (!strcmp(ev->key, "m"))))) + { + // ctrl + x + // FILLME + } + else if ((control) && (!strcmp(ev->key, "z"))) + { + // ctrl + z (undo) + // FILLME + } + else if ((control) && (!strcmp(ev->key, "y"))) + { + // ctrl + y (redo) + // FILLME + } + else if ((!strcmp(ev->key, "Return")) || (!strcmp(ev->key, "KP_Enter"))) + { + // FILLME + } + else + { + if (ev->string) + { + printf("key down string : %s\n", ev->string); + evas_object_textblock_text_markup_prepend(en->cursor, ev->string); + } + } + + /* notify cursor information */ + _imf_cursor_info_set(en); +} + +static void +_key_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Entry *en = data; + Evas_Event_Key_Up *ev = event_info; + + if (!en) return; + + if (en->imf_context) + { + Ecore_IMF_Event_Key_Up ecore_ev; + + ecore_imf_evas_event_key_up_wrap(ev, &ecore_ev); + if (ecore_imf_context_filter_event(en->imf_context, + ECORE_IMF_EVENT_KEY_UP, + (Ecore_IMF_Event *)&ecore_ev)) + return; + } +} + +static void +create_input_field(Evas *evas, Entry *en, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) +{ + if (!en) return; + + /* create background for text input field */ + en->rect = evas_object_rectangle_add(evas); + evas_object_color_set(en->rect, 150, 150, 150, 255); /* gray */ + evas_object_move(en->rect, x, y); + evas_object_resize(en->rect, w, h); + evas_object_show(en->rect); + evas_object_data_set(en->rect, "Entry", en); + + /* create text object for displaying text */ + en->txt_obj = evas_object_textblock_add(evas); + evas_object_color_set(en->txt_obj, 0, 0, 0, 255); + evas_object_pass_events_set(en->txt_obj, EINA_TRUE); + evas_object_move(en->txt_obj, x, y); + evas_object_resize(en->txt_obj, w, h); + evas_object_show(en->txt_obj); + + /* set style on textblock */ + static const char *style_buf = + "DEFAULT='font=Sans font_size=30 color=#000 text_class=entry'" + "newline='br'" + "b='+ font=Sans:style=bold'"; + en->txt_style = evas_textblock_style_new(); + evas_textblock_style_set(en->txt_style, style_buf); + evas_object_textblock_style_set(en->txt_obj, en->txt_style); + + /* create cursor */ + en->cursor = evas_object_textblock_cursor_new(en->txt_obj); + + /* create input context */ + const char *default_id = ecore_imf_context_default_id_get(); + if (!default_id) + return; + + en->imf_context = ecore_imf_context_add(default_id); + ecore_imf_context_client_window_set(en->imf_context, (void *)ecore_evas_window_get(ecore_evas_ecore_evas_get(evas))); + ecore_imf_context_client_canvas_set(en->imf_context, evas); + + evas_object_event_callback_add(en->rect, EVAS_CALLBACK_KEY_DOWN, _key_down_cb, en); + evas_object_event_callback_add(en->rect, EVAS_CALLBACK_KEY_UP, _key_up_cb, en); + evas_object_event_callback_add(en->rect, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, en); + evas_object_event_callback_add(en->rect, EVAS_CALLBACK_FOCUS_IN, _entry_focus_in_cb, en); + evas_object_event_callback_add(en->rect, EVAS_CALLBACK_FOCUS_OUT, _entry_focus_out_cb, en); + + en->have_preedit = EINA_FALSE; + en->preedit_start = NULL; + en->preedit_end = NULL; + + /* register retrieve surrounding callback */ + ecore_imf_context_retrieve_surrounding_callback_set(en->imf_context, _ecore_imf_retrieve_surrounding_cb, en); + + /* register commit event callback */ + ecore_imf_context_event_callback_add(en->imf_context, ECORE_IMF_CALLBACK_COMMIT, _ecore_imf_event_commit_cb, en); + + /* register preedit changed event handler */ + ecore_imf_context_event_callback_add(en->imf_context, ECORE_IMF_CALLBACK_PREEDIT_CHANGED, _ecore_imf_event_preedit_changed_cb, en); + + /* register surrounding delete event callback */ + ecore_imf_context_event_callback_add(en->imf_context, ECORE_IMF_CALLBACK_DELETE_SURROUNDING, _ecore_imf_event_delete_surrounding_cb, en); +} + +static void +delete_input_field(Entry *en) +{ + if (!en) return; + + if (en->rect) + { + evas_object_del(en->rect); + en->rect = NULL; + } + + if (en->cursor) + { + evas_textblock_cursor_free(en->cursor); + en->cursor = NULL; + } + + if (en->preedit_start) + { + evas_textblock_cursor_free(en->preedit_start); + en->preedit_start = NULL; + } + + if (en->preedit_end) + { + evas_textblock_cursor_free(en->preedit_end); + en->preedit_end = NULL; + } + + if (en->txt_obj) + { + evas_object_del(en->txt_obj); + en->txt_obj = NULL; + } + + if (en->txt_style) + { + evas_textblock_style_free(en->txt_style); + en->txt_style = NULL; + } + + if (en->imf_context) + { + ecore_imf_context_del(en->imf_context); + en->imf_context = NULL; + } +} + +int +main(int argc, char *argv[]) +{ + Ecore_Evas *ee; + Evas *evas; + Entry en1, en2; + + if (!ecore_evas_init()) + { + fprintf(stderr, "failed to call ecore_evas_init()\n"); + return EXIT_FAILURE; + } + + ecore_imf_init(); + + // create a new window, with size=480x800 and default engine + ee = ecore_evas_new(NULL, 0, 0, 480, 800, NULL); + + if (!ee) + { + fprintf(stderr, "failed to call ecore_evas_new\n"); + return EXIT_FAILURE; + } + + ecore_evas_show(ee); + + // get the canvas off just-created window + evas = ecore_evas_get(ee); + if (!evas) + { + fprintf(stderr, "failed to ccall ecore_evas_get\n"); + return EXIT_FAILURE; + } + + // create input field rectangle + Evas_Object *bg = evas_object_rectangle_add(evas); + evas_object_move(bg, 0, 0); + evas_object_resize(bg, 480, 800); + evas_object_color_set(bg, 255, 255, 255, 255); + evas_object_show(bg); + + evas_event_callback_add(evas, EVAS_CALLBACK_CANVAS_FOCUS_IN, _canvas_focus_in_cb, NULL); + evas_event_callback_add(evas, EVAS_CALLBACK_CANVAS_FOCUS_OUT, _canvas_focus_out_cb, NULL); + + // create input field 1 + create_input_field(evas, &en1, 40, 60, 400, 80); + + // create input field 2 + create_input_field(evas, &en2, 40, 180, 400, 80); + + // give focus to input field 1 + evas_object_focus_set(en1.rect, EINA_TRUE); + + ecore_main_loop_begin(); // begin mainloop + + delete_input_field(&en1); // delete input field 1 + delete_input_field(&en2); // delete input field 2 + + evas_event_callback_del_full(evas, EVAS_CALLBACK_CANVAS_FOCUS_IN, _canvas_focus_in_cb, NULL); + evas_event_callback_del_full(evas, EVAS_CALLBACK_CANVAS_FOCUS_OUT, _canvas_focus_out_cb, NULL); + + ecore_evas_free(ee); + + ecore_imf_shutdown(); + ecore_evas_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_job_example.c b/src/examples/ecore/ecore_job_example.c new file mode 100644 index 0000000000..561a851410 --- /dev/null +++ b/src/examples/ecore/ecore_job_example.c @@ -0,0 +1,50 @@ +#include +#include + +static void +_job_print_cb(void *data) +{ + char *str = data; + + printf("%s\n", str); +} + +static void +_job_quit_cb(void *data) +{ + ecore_main_loop_quit(); +} + +int +main(int argc, char **argv) +{ + Ecore_Job *job1, *job2, *job3, *job_quit; + char *str1 = "Job 1 started."; + char *str2 = "Job 2 started."; + char *str3 = "Job 3 started."; + + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + job1 = ecore_job_add(_job_print_cb, str1); + job2 = ecore_job_add(_job_print_cb, str2); + job3 = ecore_job_add(_job_print_cb, str3); + + job_quit = ecore_job_add(_job_quit_cb, NULL); + printf("Created jobs 1, 2, 3 and quit.\n"); + + if (job2) + { + char *str; + str = ecore_job_del(job2); + job2 = NULL; + printf("Deleted job 2. Its data was: \"%s\"\n", str); + } + + ecore_main_loop_begin(); + ecore_shutdown(); +} + diff --git a/src/examples/ecore/ecore_pipe_gstreamer_example.c b/src/examples/ecore/ecore_pipe_gstreamer_example.c new file mode 100644 index 0000000000..072aade813 --- /dev/null +++ b/src/examples/ecore/ecore_pipe_gstreamer_example.c @@ -0,0 +1,190 @@ +#include +#include + +static int nbr = 0; + +static GstElement *_buid_pipeline(gchar *filename, Ecore_Pipe *pipe); + +static void new_decoded_pad_cb(GstElement *demuxer, + GstPad *new_pad, + gpointer user_data); + +static void +handler(void *data, void *buf, unsigned int len) +{ + GstBuffer *buffer = *((GstBuffer **)buf); + + printf("handler : %p\n", buffer); + printf("frame : %d %p %lld %p\n", nbr++, data, (long long)GST_BUFFER_DURATION(buffer), buffer); + gst_buffer_unref(buffer); +} + +static void +handoff(GstElement *object, + GstBuffer *arg0, + GstPad *arg1, + gpointer user_data) +{ + Ecore_Pipe *pipe; + + pipe = (Ecore_Pipe *)user_data; + printf("handoff : %p\n", arg0); + gst_buffer_ref(arg0); + ecore_pipe_write(pipe, &arg0, sizeof(arg0)); +} + +int +main(int argc, char *argv[]) +{ + GstElement *pipeline; + char *filename; + Ecore_Pipe *pipe; + + gst_init(&argc, &argv); + + if (!ecore_init()) + { + gst_deinit(); + return 0; + } + + pipe = ecore_pipe_add(handler); + if (!pipe) + { + ecore_shutdown(); + gst_deinit(); + return 0; + } + + if (argc < 2) + { + g_print("usage: %s file.avi\n", argv[0]); + ecore_pipe_del(pipe); + ecore_shutdown(); + gst_deinit(); + return 0; + } + filename = argv[1]; + + pipeline = _buid_pipeline(filename, pipe); + if (!pipeline) + { + g_print("Error during the pipeline building\n"); + ecore_pipe_del(pipe); + ecore_shutdown(); + gst_deinit(); + return -1; + } + + gst_element_set_state(pipeline, GST_STATE_PLAYING); + + ecore_main_loop_begin(); + + ecore_pipe_del(pipe); + ecore_shutdown(); + gst_deinit(); + + return 0; +} + +static void +new_decoded_pad_cb(GstElement *demuxer, + GstPad *new_pad, + gpointer user_data) +{ + GstElement *decoder; + GstPad *pad; + GstCaps *caps; + gchar *str; + + caps = gst_pad_get_caps(new_pad); + str = gst_caps_to_string(caps); + + if (g_str_has_prefix(str, "video/")) + { + decoder = GST_ELEMENT(user_data); + + pad = gst_element_get_pad(decoder, "sink"); + if (GST_PAD_LINK_FAILED(gst_pad_link(new_pad, pad))) + { + g_warning("Failed to link %s:%s to %s:%s", GST_DEBUG_PAD_NAME(new_pad), + GST_DEBUG_PAD_NAME(pad)); + } + } + g_free(str); + gst_caps_unref(caps); +} + +static GstElement +_buid_pipeline(gchar *filename, Ecore_Pipe *pipe) +{ + GstElement *pipeline; + GstElement *filesrc; + GstElement *demuxer; + GstElement *decoder; + GstElement *sink; + GstStateChangeReturn res; + + pipeline = gst_pipeline_new("pipeline"); + if (!pipeline) + return NULL; + + filesrc = gst_element_factory_make("filesrc", "filesrc"); + if (!filesrc) + { + printf("no filesrc"); + goto failure; + } + g_object_set(G_OBJECT(filesrc), "location", filename, NULL); + + demuxer = gst_element_factory_make("oggdemux", "demuxer"); + if (!demuxer) + { + printf("no demux"); + goto failure; + } + + decoder = gst_element_factory_make("theoradec", "decoder"); + if (!decoder) + { + printf("no dec"); + goto failure; + } + + g_signal_connect(demuxer, "pad-added", + G_CALLBACK(new_decoded_pad_cb), decoder); + + sink = gst_element_factory_make("fakesink", "sink"); + if (!sink) + { + printf("no sink"); + goto failure; + } + g_object_set(G_OBJECT(sink), "sync", EINA_TRUE, NULL); + g_object_set(G_OBJECT(sink), "signal-handoffs", EINA_TRUE, NULL); + g_signal_connect(sink, "handoff", + G_CALLBACK(handoff), pipe); + + gst_bin_add_many(GST_BIN(pipeline), + filesrc, demuxer, decoder, sink, NULL); + + if (!gst_element_link(filesrc, demuxer)) + goto failure; + if (!gst_element_link(decoder, sink)) + goto failure; + + res = gst_element_set_state(pipeline, GST_STATE_PAUSED); + if (res == GST_STATE_CHANGE_FAILURE) + goto failure; + + res = gst_element_get_state(pipeline, NULL, NULL, GST_CLOCK_TIME_NONE); + if (res != GST_STATE_CHANGE_SUCCESS) + goto failure; + + return pipeline; + +failure: + gst_object_unref(GST_OBJECT(pipeline)); + return NULL; +} + diff --git a/src/examples/ecore/ecore_pipe_simple_example.c b/src/examples/ecore/ecore_pipe_simple_example.c new file mode 100644 index 0000000000..67bd4e73d1 --- /dev/null +++ b/src/examples/ecore/ecore_pipe_simple_example.c @@ -0,0 +1,67 @@ +//Compile with: +//gcc -g -Wall `pkg-config --cflags --libs ecore` -o ecore_pipe_simple_example ecore_pipe_simple_example.c + +#include +#include + +static void +do_lengthy_task(Ecore_Pipe *pipe) +{ + int i, j; + char *buffer; + for (i = 0; i < 20; i++) + { + sleep(1); + buffer = malloc(sizeof(char) * i); + for (j = 0; j < i; j++) + buffer[j] = 'a' + j; + ecore_pipe_write(pipe, buffer, i); + free(buffer); + } + ecore_pipe_write(pipe, "close", 5); +} + +static void +handler(void *data, void *buf, unsigned int len) +{ + char *str = malloc(sizeof(char) * len + 1); + memcpy(str, buf, len); + str[len] = '\0'; + printf("received %d bytes\n", len); + printf("content: %s\n", (const char *)str); + free(str); + if (len && !strncmp(buf, "close", len < 5 ? len : 5)) + { + printf("close requested\n"); + ecore_main_loop_quit(); + } +} + +int +main(int argc, char *argv[]) +{ + Ecore_Pipe *pipe; + pid_t child_pid; + + ecore_init(); + + pipe = ecore_pipe_add(handler, NULL); + + child_pid = fork(); + if (!child_pid) + { + ecore_pipe_read_close(pipe); + do_lengthy_task(pipe); + } + else + { + ecore_pipe_write_close(pipe); + ecore_main_loop_begin(); + } + + ecore_pipe_del(pipe); + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_poller_example.c b/src/examples/ecore/ecore_poller_example.c new file mode 100644 index 0000000000..ccd1c2e355 --- /dev/null +++ b/src/examples/ecore/ecore_poller_example.c @@ -0,0 +1,72 @@ +#include +#include + +static double _initial_time = 0; + +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 Eina_Bool +_poller_quit_cb(void *data) +{ + + ecore_main_loop_quit(); + return EINA_TRUE; +} + +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(); +} + diff --git a/src/examples/ecore/ecore_server_bench.c b/src/examples/ecore/ecore_server_bench.c new file mode 100644 index 0000000000..1f9b63a890 --- /dev/null +++ b/src/examples/ecore/ecore_server_bench.c @@ -0,0 +1,63 @@ +#include +#include +#include + +/* Ecore_Con server example + * 2010 Mike Blumenkrantz + */ + +static Ecore_Con_Server *svr; +static int add; +static int del; + +Eina_Bool +_add(void *data, int type, Ecore_Con_Event_Client_Add *ev) +{ + ++add; +// printf ("%s ", ecore_con_client_ip_get(ev->client)); + printf("Client #%i!\n", add); + return ECORE_CALLBACK_RENEW; +} + +Eina_Bool +_del(void *data, int type, Ecore_Con_Event_Client_Del *ev) +{ + ++del; + printf("Disconnected #%i!\n", del); + if (add == del) + ecore_main_loop_quit(); + return ECORE_CALLBACK_RENEW; +} + +int +main(int argc, const char *argv[]) +{ + ecore_init(); + ecore_con_init(); + ecore_app_args_set(argc, argv); + eina_log_domain_level_set("ecore_con", EINA_LOG_LEVEL_ERR); + eina_log_domain_level_set("eina", EINA_LOG_LEVEL_ERR); + +/* to use a PEM certificate with TLS and SSL3, uncomment the lines below */ +// if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_NODELAY | ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT, "127.0.0.1", 8080, NULL))) + +/* to use simple tcp with ssl/tls, use this line */ + svr = ecore_con_server_add(ECORE_CON_REMOTE_NODELAY, "127.0.0.1", 8080, NULL); + if (!svr) + exit(1); + + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL); + ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL); + +/* start server */ + ecore_main_loop_begin(); + if (add && del) + { + printf("Restarting server after %i connections\n", add); + add = del = 0; + ecore_con_server_del(svr); + ecore_app_restart(); + } + return 0; +} + diff --git a/src/examples/ecore/ecore_thread_example.c b/src/examples/ecore/ecore_thread_example.c new file mode 100644 index 0000000000..a34491911b --- /dev/null +++ b/src/examples/ecore/ecore_thread_example.c @@ -0,0 +1,397 @@ +/* + * gcc -o ecore_thread_example ecore_thread_example.c `pkg-config --cflags --libs ecore` + */ +#include +#include +#include +#include + +#include +#include + +typedef struct +{ + Ecore_Thread *thread_3; + int msgs_received; + int max_msgs; + Eina_Lock mutex; + Eina_Condition condition; +} App_Data; + +typedef struct +{ + Eina_List *list; +} Thread_Data; + +typedef struct +{ + char *name; + char *base; + Eina_Lock mutex; +} Feedback_Thread_Data; + +typedef struct +{ + int all_done; + Eina_List *list; +} App_Msg; + +static void +_local_data_free(void *data) +{ + Thread_Data *td = data; + char *str; + + EINA_LIST_FREE(td->list, str) + { + printf("Freeing string: %s\n", str); + free(str); + } + free(td); +} + +static void +_short_job(void *data, Ecore_Thread *th) +{ + Thread_Data *td; + int i; + + td = ecore_thread_local_data_find(th, "data"); + if (!td) + { + td = calloc(1, sizeof(Thread_Data)); + if (!td) + { + ecore_thread_cancel(th); + return; + } + ecore_thread_local_data_add(th, "data", td, _local_data_free, + EINA_FALSE); + } + + for (i = 0; i < 10; i++) + { + char buf[200]; + + if (ecore_thread_check(th)) + { + ecore_thread_local_data_del(th, "data"); + break; + } + + snprintf(buf, sizeof(buf), "Thread %p: String number %d", th, i); + td->list = eina_list_append(td->list, strdup(buf)); + sleep(1); + } +} + +static void +_feedback_job(void *data, Ecore_Thread *th) +{ + time_t t; + int i, count; + Feedback_Thread_Data *ftd = NULL; + DIR *dir; + App_Msg *msg; + + count = (int)ecore_thread_global_data_find("count"); + for (i = 0; i < count; i++) + { + char buf[32]; + snprintf(buf, sizeof(buf), "data%d", i); + ftd = ecore_thread_global_data_find(buf); + if (!ftd) + continue; + if (eina_lock_take_try(&ftd->mutex)) + break; + else + ftd = NULL; + } + if (!ftd) + return; + + dir = opendir(ftd->base); + if (!dir) + goto the_end; + + msg = calloc(1, sizeof(App_Msg)); + + t = time(NULL); + while (time(NULL) < t + 2) + { + struct dirent entry, *result; + + if (readdir_r(dir, &entry, &result)) + break; + if (!result) + break; + + if (strlen(result->d_name) >= 10) + msg->list = eina_list_append(msg->list, + strdup(result->d_name)); + } + + closedir(dir); + ecore_thread_feedback(th, msg); + +the_end: + ecore_thread_global_data_del(ftd->name); + free(ftd->name); + free(ftd->base); + eina_lock_release(&ftd->mutex); + eina_lock_free(&ftd->mutex); + free(ftd); + ecore_thread_reschedule(th); +} + +static void +_out_of_pool_job(void *data, Ecore_Thread *th) +{ + App_Data *ad = data; + App_Msg *msg; + + while (1) + { + int msgs; + eina_condition_wait(&ad->condition); + msgs = ad->msgs_received; + eina_lock_release(&ad->mutex); + if (msgs == ad->max_msgs) + { + msg = calloc(1, sizeof(App_Msg)); + msg->all_done = 1; + ecore_thread_feedback(th, msg); + return; + } + } +} + +static void +_print_status(void) +{ + int active, pending_total, pending_feedback, pending_short, available; + + active = ecore_thread_active_get(); + pending_total = ecore_thread_pending_total_get(); + pending_feedback = ecore_thread_pending_feedback_get(); + pending_short = ecore_thread_pending_get(); + available = ecore_thread_available_get(); + + printf("Status:\n\t* Active threads: %d\n" + "\t* Available threads: %d\n" + "\t* Pending short jobs: %d\n" + "\t* Pending feedback jobs: %d\n" + "\t* Pending total: %d\n", active, available, pending_short, + pending_feedback, pending_total); +} + +static void +_feedback_job_msg_cb(void *data, Ecore_Thread *th, void *msg_data) +{ + App_Data *ad = data; + App_Msg *msg = msg_data; + char *str; + + if (msg->all_done) + { + ecore_main_loop_quit(); + free(msg); + return; + } + + _print_status(); + + if (!msg->list) + printf("Received an empty list from thread %p\n", th); + else + { + int i = 0; + printf("Received %d elements from threads %p (printing first 5):\n", + eina_list_count(msg->list), th); + EINA_LIST_FREE(msg->list, str) + { + if (i <= 5) + printf("\t%s\n", str); + free(str); + i++; + } + } + + eina_lock_take(&ad->mutex); + ad->msgs_received++; + eina_condition_signal(&ad->condition); + eina_lock_release(&ad->mutex); + + free(msg); +} + +static void +_thread_end_cb(void *data, Ecore_Thread *th) +{ + App_Data *ad = data; + + printf("Normal termination for thread %p.\n", th); + if (th == ad->thread_3) + ad->thread_3 = NULL; +} + +static void +_thread_cancel_cb(void *data, Ecore_Thread *th) +{ + App_Data *ad = data; + + printf("Thread %p got cancelled.\n", th); + if (th == ad->thread_3) + ad->thread_3 = NULL; +} + +static Eina_Bool +_cancel_timer_cb(void *data) +{ + App_Data *ad = data; + + if (ad->thread_3 && !ecore_thread_check(ad->thread_3)) + ecore_thread_cancel(ad->thread_3); + + return EINA_FALSE; +} + +static Eina_Bool +_status_timer_cb(void *data) +{ + _print_status(); + + return EINA_TRUE; +} + +static const Ecore_Getopt optdesc = { + "ecore_thread_example", + NULL, + "0.0", + "(C) 2011 Enlightenment", + "Public domain?", + "Example program for Ecore_Thread", + 0, + { + ECORE_GETOPT_STORE_INT('t', "threads", "Max number of threads to run"), + ECORE_GETOPT_STORE_INT('m', "msgs", "Max number of messages to receive"), + ECORE_GETOPT_APPEND_METAVAR('p', "path", "Add path for feedback job", + "STRING", ECORE_GETOPT_TYPE_STR), + ECORE_GETOPT_HELP('h', "help"), + ECORE_GETOPT_SENTINEL + } +}; + +int +main(int argc, char *argv[]) +{ + int i, max_threads = 0, max_msgs = 0; + Eina_Bool opt_quit = EINA_FALSE; + Eina_List *path_list = NULL; + App_Data appdata; + Ecore_Getopt_Value values[] = { + ECORE_GETOPT_VALUE_INT(max_threads), + ECORE_GETOPT_VALUE_INT(max_msgs), + ECORE_GETOPT_VALUE_LIST(path_list), + ECORE_GETOPT_VALUE_BOOL(opt_quit), + ECORE_GETOPT_VALUE_NONE + }; + + ecore_init(); + + i = ecore_thread_max_get(); + printf("Initial max threads: %d\n", i); + + memset(&appdata, 0, sizeof(App_Data)); + appdata.max_msgs = 1; + + if (ecore_getopt_parse(&optdesc, values, argc, argv) < 0) + { + printf("Argument parsing failed\n"); + return 1; + } + + if (opt_quit) + return 0; + + if (max_threads) + { + ecore_thread_max_set(max_threads); + printf("Max threads: %d\n", ecore_thread_max_get()); + } + if (max_msgs) + appdata.max_msgs = max_msgs; + + if (!path_list) + { + Feedback_Thread_Data *ftd; + ecore_thread_global_data_add("count", (void *)3, NULL, EINA_FALSE); + ftd = calloc(1, sizeof(Feedback_Thread_Data)); + ftd->name = strdup("data0"); + ftd->base = strdup("/usr/bin"); + eina_lock_new(&ftd->mutex); + ecore_thread_global_data_add(ftd->name, ftd, NULL, EINA_TRUE); + ftd = calloc(1, sizeof(Feedback_Thread_Data)); + ftd->name = strdup("data1"); + ftd->base = strdup("/usr/lib"); + eina_lock_new(&ftd->mutex); + ecore_thread_global_data_add(ftd->name, ftd, NULL, EINA_TRUE); + ftd = calloc(1, sizeof(Feedback_Thread_Data)); + ftd->name = strdup("data2"); + ftd->base = strdup("/usr/share"); + eina_lock_new(&ftd->mutex); + ecore_thread_global_data_add(ftd->name, ftd, NULL, EINA_TRUE); + } + else + { + Feedback_Thread_Data *ftd; + char *str; + ecore_thread_global_data_add("count", + (void *)eina_list_count(path_list), NULL, + EINA_FALSE); + i = 0; + EINA_LIST_FREE(path_list, str) + { + char buf[32]; + snprintf(buf, sizeof(buf), "data%d", i); + ftd = calloc(1, sizeof(Feedback_Thread_Data)); + ftd->name = strdup(buf); + ftd->base = strdup(str); + eina_lock_new(&ftd->mutex); + ecore_thread_global_data_add(ftd->name, ftd, NULL, EINA_TRUE); + free(str); + i++; + } + } + + eina_lock_new(&appdata.mutex); + eina_condition_new(&appdata.condition, &appdata.mutex); + + ecore_thread_feedback_run(_out_of_pool_job, _feedback_job_msg_cb, NULL, + NULL, &appdata, EINA_TRUE); + + ecore_thread_run(_short_job, _thread_end_cb, _thread_cancel_cb, &appdata); + ecore_thread_feedback_run(_feedback_job, _feedback_job_msg_cb, + _thread_end_cb, _thread_cancel_cb, &appdata, + EINA_FALSE); + appdata.thread_3 = ecore_thread_run(_short_job, _thread_end_cb, + _thread_cancel_cb, &appdata); + ecore_thread_feedback_run(_feedback_job, _feedback_job_msg_cb, + _thread_end_cb, _thread_cancel_cb, &appdata, + EINA_FALSE); + + ecore_timer_add(1.0, _cancel_timer_cb, &appdata); + ecore_timer_add(2.0, _status_timer_cb, NULL); + + _print_status(); + + ecore_main_loop_begin(); + + eina_condition_free(&appdata.condition); + eina_lock_free(&appdata.mutex); + + ecore_shutdown(); + + return 0; +} + diff --git a/src/examples/ecore/ecore_time_functions_example.c b/src/examples/ecore/ecore_time_functions_example.c new file mode 100644 index 0000000000..d742c8be3c --- /dev/null +++ b/src/examples/ecore/ecore_time_functions_example.c @@ -0,0 +1,34 @@ +#include +#include + +static Eina_Bool +_timer_cb(void *data) +{ + printf("ecore time: %0.3f\n", ecore_time_get()); + printf("loop time: %0.3f\n", ecore_loop_time_get()); + printf("unix time: %0.3f\n", ecore_time_unix_get()); + printf("\nSleep for 1 second...\n\n"); + sleep(1); + printf("ecore time: %0.3f\n", ecore_time_get()); + printf("loop time: %0.3f\n", ecore_loop_time_get()); + printf("unix time: %0.3f\n", ecore_time_unix_get()); + + ecore_main_loop_quit(); + + return EINA_FALSE; +} + +int +main(int argc, char **argv) +{ + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + ecore_timer_add(0.1, _timer_cb, NULL); + ecore_main_loop_begin(); + ecore_shutdown(); +} + diff --git a/src/examples/ecore/ecore_timer_example.c b/src/examples/ecore/ecore_timer_example.c new file mode 100644 index 0000000000..bafeacb69c --- /dev/null +++ b/src/examples/ecore/ecore_timer_example.c @@ -0,0 +1,187 @@ +#include +#include + +#define TIMEOUT_1 1.0 // interval for timer1 +#define TIMEOUT_2 3.0 // timer2 - delay timer1 +#define TIMEOUT_3 8.2 // timer3 - pause timer1 +#define TIMEOUT_4 11.0 // timer4 - resume timer1 +#define TIMEOUT_5 14.0 // timer5 - change interval of timer1 +#define TIMEOUT_6 18.0 // top timer1 and start timer7 and timer8 with changed precision +#define TIMEOUT_7 1.1 // interval for timer7 +#define TIMEOUT_8 1.2 // interval for timer8 +#define DELAY_1 3.0 // delay time for timer1 - used by timer2 +#define INTERVAL1 2.0 // new interval for timer1 - used by timer5 + +static double _initial_time = 0; + +struct context // helper struct to give some context to the callbacks +{ + Ecore_Timer *timer1; + Ecore_Timer *timer2; + Ecore_Timer *timer3; + Ecore_Timer *timer4; + Ecore_Timer *timer5; + Ecore_Timer *timer6; + Ecore_Timer *timer7; + Ecore_Timer *timer8; +}; + +static double +_get_current_time(void) +{ + return ecore_time_get() - _initial_time; +} + +static Eina_Bool +_timer1_cb(void *data) +{ + printf("Timer1 expired after %0.3f seconds.\n", _get_current_time()); + return ECORE_CALLBACK_RENEW; +} + +static Eina_Bool +_timer2_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer2 expired after %0.3f seconds. " + "Adding delay of %0.3f seconds to timer1.\n", + _get_current_time(), DELAY_1); + + ecore_timer_delay(ctxt->timer1, DELAY_1); + + ctxt->timer2 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer3_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer3 expired after %0.3f seconds. " + "Freezing timer1.\n", _get_current_time()); + + ecore_timer_freeze(ctxt->timer1); + + ctxt->timer3 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer4_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer4 expired after %0.3f seconds. " + "Resuming timer1, which has %0.3f seconds left to expire.\n", + _get_current_time(), ecore_timer_pending_get(ctxt->timer1)); + + ecore_timer_thaw(ctxt->timer1); + + ctxt->timer4 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer5_cb(void *data) +{ + struct context *ctxt = data; + double interval = ecore_timer_interval_get(ctxt->timer1); + + printf("Timer5 expired after %0.3f seconds. " + "Changing interval of timer1 from %0.3f to %0.3f seconds.\n", + _get_current_time(), interval, INTERVAL1); + + ecore_timer_interval_set(ctxt->timer1, INTERVAL1); + + ctxt->timer5 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer7_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer7 expired after %0.3f seconds.\n", _get_current_time()); + + ctxt->timer7 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer8_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer8 expired after %0.3f seconds.\n", _get_current_time()); + + ctxt->timer8 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer6_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer6 expired after %0.3f seconds.\n", _get_current_time()); + + printf("Stopping timer1.\n"); + + ecore_timer_del(ctxt->timer1); + ctxt->timer1 = NULL; + + printf("Starting timer7 (%0.3fs) and timer8 (%0.3fs).\n", + TIMEOUT_7, TIMEOUT_8); + + ctxt->timer7 = ecore_timer_add(TIMEOUT_7, _timer7_cb, ctxt); + ctxt->timer8 = ecore_timer_add(TIMEOUT_8, _timer8_cb, ctxt); + + ecore_timer_precision_set(0.2); + + ctxt->timer6 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +int +main(int argc, char **argv) +{ + struct context ctxt = {0}; + + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + _initial_time = ecore_time_get(); + + ctxt.timer1 = ecore_timer_add(TIMEOUT_1, _timer1_cb, &ctxt); + ctxt.timer2 = ecore_timer_add(TIMEOUT_2, _timer2_cb, &ctxt); + ctxt.timer3 = ecore_timer_add(TIMEOUT_3, _timer3_cb, &ctxt); + ctxt.timer4 = ecore_timer_add(TIMEOUT_4, _timer4_cb, &ctxt); + ctxt.timer5 = ecore_timer_add(TIMEOUT_5, _timer5_cb, &ctxt); + ctxt.timer6 = ecore_timer_add(TIMEOUT_6, _timer6_cb, &ctxt); + + printf("start the main loop.\n"); + + ecore_main_loop_begin(); + + if (ctxt.timer1) + ecore_timer_del(ctxt.timer1); + if (ctxt.timer2) + ecore_timer_del(ctxt.timer2); + if (ctxt.timer3) + ecore_timer_del(ctxt.timer3); + if (ctxt.timer4) + ecore_timer_del(ctxt.timer4); + if (ctxt.timer5) + ecore_timer_del(ctxt.timer5); + if (ctxt.timer6) + ecore_timer_del(ctxt.timer6); + if (ctxt.timer7) + ecore_timer_del(ctxt.timer7); + if (ctxt.timer8) + ecore_timer_del(ctxt.timer8); + + ecore_shutdown(); + + return 0; +} + diff --git a/legacy/edje/src/examples/red.png b/src/examples/ecore/red.png similarity index 100% rename from legacy/edje/src/examples/red.png rename to src/examples/ecore/red.png