forked from enlightenment/efl
428 lines
11 KiB
Plaintext
428 lines
11 KiB
Plaintext
/**
|
|
* @page eio_examples Eio Examples
|
|
*
|
|
* Here is a page with some Eio examples explained:
|
|
*
|
|
* @li @ref eio_file_ls.c
|
|
*
|
|
* Tutorials:
|
|
* @li @ref tutorial_dir_copy
|
|
* @li @ref tutorial_dir_stat_ls
|
|
* @li @ref tutorial_file_ls
|
|
* @li @ref tutorial_dir_direct_ls
|
|
* @li @ref tutorial_monitor_add
|
|
*
|
|
* @example eio_file_ls.c
|
|
*/
|
|
|
|
/**
|
|
* @page tutorial_dir_copy eio_dir_copy() tutorial
|
|
*
|
|
* To use eio_dir_copy(), you basically need the source and
|
|
* destination files (or directories), and set three callbacks:
|
|
*
|
|
* @li The notification callback, which allows you to know if a file or
|
|
* a directory is copied, and the progress of the copy.
|
|
* @li The end callback, which is called when the copy is finished.
|
|
* @li The error callback, which is called if an error occurred. You
|
|
* can then retrieve the error type as an errno error.
|
|
*
|
|
* @warning It is the user's duty to provide the "right target". It
|
|
* means that copying to '.' will copy the content directly inside '.'
|
|
* and not in a subdirectory.
|
|
*
|
|
* Here is a simple example:
|
|
*
|
|
* @code
|
|
* #include <Ecore.h>
|
|
* #include <Eio.h>
|
|
*
|
|
* static void
|
|
* _test_notify_cb(void *data, Eio_File *handler, const Eio_Progress *info)
|
|
* {
|
|
* switch (info->op)
|
|
* {
|
|
* case EIO_FILE_COPY:
|
|
* printf("[%s] %f%%\n", info->dest, info->percent);
|
|
* break;
|
|
* case EIO_DIR_COPY:
|
|
* printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
|
|
* break;
|
|
* }
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_done_cb(void *data, Eio_File *handler)
|
|
* {
|
|
* printf("copy done\n");
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_error_cb(int error, Eio_File *handler, void *data)
|
|
* {
|
|
* fprintf(stderr, "error: [%s]\n", strerror(error));
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* int
|
|
* main(int argc, char **argv)
|
|
* {
|
|
* Eio_File *cp;
|
|
*
|
|
* if (argc != 3)
|
|
* {
|
|
* fprintf(stderr, "eio_cp source_file destination_file\n");
|
|
* return -1;
|
|
* }
|
|
*
|
|
* ecore_init();
|
|
* eio_init();
|
|
*
|
|
* cp = eio_dir_copy(argv[1], argv[2],
|
|
* _test_notify_cb,
|
|
* _test_done_cb,
|
|
* _test_error_cb,
|
|
* NULL);
|
|
*
|
|
* ecore_main_loop_begin();
|
|
*
|
|
* eio_shutdown();
|
|
* ecore_shutdown();
|
|
*
|
|
* return 0;
|
|
* }
|
|
* @endcode
|
|
*/
|
|
|
|
/**
|
|
* @page tutorial_dir_stat_ls eio_dir_stat_ls() tutorial
|
|
*
|
|
* @li The filter callback, which allow or not a file to be seen
|
|
* by the main loop handler. This callback run in a separated thread.
|
|
* @li The main callback, which receive in the main loop all the file
|
|
* that are allowed by the filter. If you are updating a user interface
|
|
* it make sense to delay the insertion a little, so you get a chance
|
|
* to update the canvas for a bunch of file instead of one by one.
|
|
* @li The end callback, which is called in the main loop when the
|
|
* content of the directory has been correctly scanned and all the
|
|
* file notified to the main loop.
|
|
* @li The error callback, which is called if an error occurred or
|
|
* if the listing was cancelled during it's run. You can then retrieve
|
|
* the error type as an errno error.
|
|
*
|
|
* Here is a simple example that implement a stupidly simple replacement for find:
|
|
*
|
|
* @code
|
|
* #include <Ecore.h>
|
|
* #include <Eio.h>
|
|
*
|
|
* static Eina_Bool
|
|
* _test_filter_cb(void *data, Eio_File *handler, const Eina_File_Direct_Info *info)
|
|
* {
|
|
* fprintf(stderr, "ACCEPTING: %s\n", info->path);
|
|
* return EINA_TRUE;
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_main_cb(void *data, Eio_File *handler, const Eina_File_Direct_Info *info)
|
|
* {
|
|
* fprintf(stderr, "PROCESS: %s\n", info->path);
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_done_cb(void *data, Eio_File *handler)
|
|
* {
|
|
* printf("ls done\n");
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_error_cb(void *data, Eio_File *handler, int error)
|
|
* {
|
|
* fprintf(stderr, "error: [%s]\n", strerror(error));
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* int
|
|
* main(int argc, char **argv)
|
|
* {
|
|
* Eio_File *cp;
|
|
*
|
|
* if (argc != 2)
|
|
* {
|
|
* fprintf(stderr, "eio_ls directory\n");
|
|
* return -1;
|
|
* }
|
|
*
|
|
* ecore_init();
|
|
* eio_init();
|
|
*
|
|
* cp = eio_dir_stat_ls(argv[1],
|
|
* _test_filter_cb,
|
|
* _test_main_cb,
|
|
* _test_done_cb,
|
|
* _test_error_cb,
|
|
* NULL);
|
|
*
|
|
* ecore_main_loop_begin();
|
|
*
|
|
* eio_shutdown();
|
|
* ecore_shutdown();
|
|
*
|
|
* return 0;
|
|
* }
|
|
*
|
|
* @endcode
|
|
*/
|
|
|
|
/**
|
|
* @page tutorial_file_ls eio_file_ls() tutorial
|
|
*
|
|
* To use eio_file_ls(), you just need to define four callbacks:
|
|
*
|
|
* @li The filter callback, which allows a file to be seen (or not)
|
|
* by the main loop handler. This callback runs in a separate thread.
|
|
* @li The main callback, which receive in the main loop all the file
|
|
* that are allowed by the filter. If you are updating a user interface
|
|
* it makes sense to delay the insertion a little, so you get a chance
|
|
* to update the canvas for a bunch of files instead of one by one.
|
|
* @li The end callback, which is called in the main loop when the
|
|
* content of the directory has been correctly scanned and all the
|
|
* file notified to the main loop.
|
|
* @li The error callback, which is called if an error occurred or
|
|
* if the listing was cancelled during its run. You can then retrieve
|
|
* the error type as an errno error.
|
|
*
|
|
* Here is a simple example:
|
|
*
|
|
* @code
|
|
* #include <Ecore.h>
|
|
* #include <Eio.h>
|
|
*
|
|
* static Eina_Bool
|
|
* _test_filter_cb(void *data, Eio_File *handler, const char *file)
|
|
* {
|
|
* fprintf(stderr, "ACCEPTING: %s\n", file);
|
|
* return EINA_TRUE;
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_main_cb(void *data, Eio_File *handler, const char *file)
|
|
* {
|
|
* fprintf(stderr, "PROCESS: %s\n", file);
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_done_cb(void *data, Eio_File *handler)
|
|
* {
|
|
* printf("ls done\n");
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_error_cb(void *data, Eio_File *handler, int error)
|
|
* {
|
|
* fprintf(stderr, "error: [%s]\n", strerror(error));
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* int
|
|
* main(int argc, char **argv)
|
|
* {
|
|
* Eio_File *cp;
|
|
*
|
|
* if (argc != 2)
|
|
* {
|
|
* fprintf(stderr, "eio_ls directory\n");
|
|
* return -1;
|
|
* }
|
|
*
|
|
* ecore_init();
|
|
* eio_init();
|
|
*
|
|
* cp = eio_file_ls(argv[1],
|
|
* _test_filter_cb,
|
|
* _test_main_cb,
|
|
* _test_done_cb,
|
|
* _test_error_cb,
|
|
* NULL);
|
|
*
|
|
* ecore_main_loop_begin();
|
|
*
|
|
* eio_shutdown();
|
|
* ecore_shutdown();
|
|
*
|
|
* return 0;
|
|
* }
|
|
*
|
|
* @endcode
|
|
*/
|
|
|
|
/**
|
|
* @page tutorial_monitor_add eio_monitor_add() tutorial
|
|
*
|
|
* To use eio_monitor_add(), you have to define callbacks
|
|
* for events declared by eio.
|
|
* Available events are :
|
|
* - EIO_MONITOR_FILE_CREATED
|
|
* - EIO_MONITOR_FILE_DELETED
|
|
* - EIO_MONITOR_FILE_MODIFIED
|
|
* - EIO_MONITOR_FILE_CLOSED
|
|
* - EIO_MONITOR_DIRECTORY_CREATED
|
|
* - EIO_MONITOR_DIRECTORY_DELETED
|
|
* - EIO_MONITOR_DIRECTORY_CLOSED
|
|
* - EIO_MONITOR_SELF_RENAME
|
|
* - EIO_MONITOR_SELF_DELETED
|
|
*
|
|
* As nothing is worth an example, here it is :
|
|
* @code
|
|
* #include <Eina.h>
|
|
* #include <Ecore.h>
|
|
* #include <Eio.h>
|
|
*
|
|
* void file_modified(void *data, int type, void *event)
|
|
* {
|
|
* const char *filename = (const char *)data;
|
|
* printf("file %s ", filename);
|
|
* if( type == EIO_MONITOR_FILE_MODIFIED )
|
|
* printf("is being modified");
|
|
* else if( type == EIO_MONITOR_FILE_CLOSED )
|
|
* printf("is no longer being modified");
|
|
* else printf("got unexpected changes");
|
|
* printf("\n");
|
|
* }
|
|
*
|
|
* int main(int argc, char **argv) {
|
|
* Eio_Monitor *monitor = NULL,
|
|
* *monitor2 = NULL;
|
|
* eio_init();
|
|
* const char *filename = eina_stringshare_add("/tmp/eio_notify_testfile");
|
|
*
|
|
* monitor = eio_monitor_add(filename);
|
|
* ecore_event_handler_add(EIO_MONITOR_FILE_MODIFIED, (Ecore_Event_Handler_Cb)file_modified, filename);
|
|
* ecore_event_handler_add(EIO_MONITOR_FILE_CLOSED, (Ecore_Event_Handler_Cb)file_modified, filename);
|
|
*
|
|
* ecore_main_loop_begin();
|
|
* eio_shutdown();
|
|
* eina_stringshare_del(filename);
|
|
* }
|
|
* @endcode
|
|
* Build the example doing :
|
|
* @verbatim gcc -o tutorial_monitor_add tutorial_monitor_add.c `pkg-config --libs --cflags eio ecore ecore-file eina`
|
|
* then create the file /tmp/eio_notify_testfile :
|
|
* touch /tmp/eio_notify_testfile
|
|
* and launch tutorial_monitor_add, and in another terminal, write into /tmp/eio_notify_testfile, doing for example :
|
|
* echo "test" >> /tmp/eio_notify_testfile
|
|
* @endverbatim
|
|
*/
|
|
|
|
/**
|
|
* @page tutorial_dir_direct_ls eio_dir_direct_ls() tutorial
|
|
*
|
|
* @li The filter callback, which allow or not a file to be seen
|
|
* by the main loop handler. This callback run in a separated thread.
|
|
* It also take care of getting a stat buffer needed by the main callback
|
|
* to display the file size.
|
|
* @li The main callback, which receive in the main loop all the file
|
|
* that are allowed by the filter. If you are updating a user interface
|
|
* it make sense to delay the insertion a little, so you get a chance
|
|
* to update the canvas for a bunch of file instead of one by one.
|
|
* @li The end callback, which is called in the main loop when the
|
|
* content of the directory has been correctly scanned and all the
|
|
* file notified to the main loop.
|
|
* @li The error callback, which is called if an error occurred or
|
|
* if the listing was cancelled during it's run. You can then retrieve
|
|
* the error type as an errno error.
|
|
*
|
|
* Here is a simple example that implement a stupidly simple recursive ls that display file size:
|
|
*
|
|
* @code
|
|
* #include <Eina.h>
|
|
* #include <Ecore.h>
|
|
* #include <Eio.h>
|
|
*
|
|
* static Eina_Bool
|
|
* _test_filter_cb(void *data, Eio_File *handler, Eina_File_Direct_Info *info)
|
|
* {
|
|
* Eina_Stat *buffer;
|
|
* Eina_Bool isdir;
|
|
*
|
|
* isdir = info->type == EINA_FILE_DIR;
|
|
*
|
|
* buffer = malloc(sizeof (Eina_Stat));
|
|
* if (eina_file_statat(eio_file_container_get(handler), info, buffer))
|
|
* {
|
|
* free(buffer);
|
|
* return EINA_FALSE;
|
|
* }
|
|
*
|
|
* if (!isdir && info->type == EINA_FILE_DIR)
|
|
* {
|
|
* struct stat st;
|
|
* if (lstat(info->path, &st) == 0)
|
|
* {
|
|
* if (S_ISLNK(st.st_mode))
|
|
* info->type = EINA_FILE_LNK;
|
|
* }
|
|
* }
|
|
*
|
|
* eio_file_associate_direct_add(handler, "stat", buffer, free);
|
|
* fprintf(stdout, "ACCEPTING: %s\n", info->path);
|
|
* return EINA_TRUE;
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_main_cb(void *data, Eio_File *handler, const Eina_File_Direct_Info *info)
|
|
* {
|
|
* struct stat *buffer;
|
|
*
|
|
* buffer = eio_file_associate_find(handler, "stat");
|
|
* fprintf(stdout, "PROCESS: %s of size %li\n", info->path, buffer->st_size);
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_done_cb(void *data, Eio_File *handler)
|
|
* {
|
|
* printf("ls done\n");
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* static void
|
|
* _test_error_cb(void *data, Eio_File *handler, int error)
|
|
* {
|
|
* fprintf(stdout, "error: [%s]\n", strerror(error));
|
|
* ecore_main_loop_quit();
|
|
* }
|
|
*
|
|
* int
|
|
* main(int argc, char **argv)
|
|
* {
|
|
* Eio_File *cp;
|
|
*
|
|
* if (argc != 2)
|
|
* {
|
|
* fprintf(stdout, "eio_ls directory\n");
|
|
* return -1;
|
|
* }
|
|
*
|
|
* ecore_init();
|
|
* eio_init();
|
|
*
|
|
* cp = eio_dir_direct_ls(argv[1],
|
|
* _test_filter_cb,
|
|
* _test_main_cb,
|
|
* _test_done_cb,
|
|
* _test_error_cb,
|
|
* NULL);
|
|
*
|
|
* ecore_main_loop_begin();
|
|
*
|
|
* eio_shutdown();
|
|
* ecore_shutdown();
|
|
*
|
|
* return 0;
|
|
* }
|
|
* @endcode
|
|
*/
|