From 25605153e312bdae2742b643c1d98eb2cd1d5a61 Mon Sep 17 00:00:00 2001 From: "Carsten Haitzler (Rasterman)" Date: Wed, 3 Dec 2014 08:42:29 +0900 Subject: [PATCH] Revert "get rid of application server" This reverts commit 3ffe45d1c617e493292a7f65752f9726e762d632. --- Marrakesh.mrk | 4 + src/bin/Makefile.am | 2 + src/bin/app_server.c | 442 +++++++++++++++++++++++++++++++++++++ src/bin/app_server.h | 11 + src/bin/app_server_eet.c | 252 +++++++++++++++++++++ src/bin/app_server_eet.h | 38 ++++ src/bin/config.c | 11 + src/bin/config.h | 2 + src/bin/main.c | 7 + src/bin/options_behavior.c | 69 ++++++ src/bin/win.c | 7 + 11 files changed, 845 insertions(+) create mode 100644 src/bin/app_server.c create mode 100644 src/bin/app_server.h create mode 100644 src/bin/app_server_eet.c create mode 100644 src/bin/app_server_eet.h diff --git a/Marrakesh.mrk b/Marrakesh.mrk index b8693930..27d0a420 100644 --- a/Marrakesh.mrk +++ b/Marrakesh.mrk @@ -21,6 +21,10 @@ SRC: terminology_config.h src/bin/about.c src/bin/about.h +src/bin/app_server.c +src/bin/app_server_eet.c +src/bin/app_server_eet.h +src/bin/app_server.h src/bin/col.c src/bin/col.h src/bin/config.c diff --git a/src/bin/Makefile.am b/src/bin/Makefile.am index 7a25533e..23672fac 100644 --- a/src/bin/Makefile.am +++ b/src/bin/Makefile.am @@ -57,6 +57,8 @@ term_container.h \ utils.c utils.h \ dbus.c dbus.h \ extns.c extns.h \ +app_server.c app_server.h \ +app_server_eet.c app_server_eet.h \ gravatar.c gravatar.h \ tty_keys.h diff --git a/src/bin/app_server.c b/src/bin/app_server.c new file mode 100644 index 00000000..6885d6dd --- /dev/null +++ b/src/bin/app_server.c @@ -0,0 +1,442 @@ +#include "private.h" + +#include + +#include "main.h" +#include "termio.h" +#include "app_server_eet.h" + +#if 0 +//#if (ELM_VERSION_MAJOR > 1) || (ELM_VERSION_MINOR >= 10) + +#ifndef ELM_APP_SERVER_VIEW_EVENT_CLOSED +#define ELM_APP_SERVER_VIEW_EVENT_CLOSED ELM_APP_SERVER_VIEW_EV_CLOSED +#endif + +#ifndef ELM_APP_SERVER_VIEW_EVENT_RESUMED +#define ELM_APP_SERVER_VIEW_EVENT_RESUMED ELM_APP_SERVER_VIEW_EV_RESUMED +#endif + +#ifndef ELM_APP_SERVER_VIEW_EVENT_SAVE +#define ELM_APP_SERVER_VIEW_EVENT_SAVE ELM_APP_SERVER_VIEW_EV_SAVE +#endif + +#ifndef ELM_APP_SERVER_EVENT_TERMINATE +#define ELM_APP_SERVER_EVENT_TERMINATE ELM_APP_SERVER_EV_TERMINATE +#endif + +static Elm_App_Server *_server = NULL; +static Eina_Bool _ignore_term_add = EINA_FALSE; +static Terminology_Item *views_eet = NULL; + +static void +_user_config_file_path_build(char *dir, unsigned int size, const char *id) +{ + const char *home = getenv("HOME"); + + if (!home) + home = ""; + + snprintf(dir, size, "%s/.terminology/", home); + if (!ecore_file_is_dir(dir)) + ecore_file_mkpath(dir); + + snprintf(dir, size, "%s/.terminology/%s", home, id); +} + +void +app_server_term_del(Evas_Object *term) +{ + Elm_App_Server_View *view; + const char *id = NULL; + + view = evas_object_data_del(term, "app_view"); + if (!view) + return; + + eo_do(view, id = elm_app_server_view_id_get()); + terminology_item_term_entries_del(views_eet, id); + + eo_del(view); +} + +static Eina_Bool +_view_closed_cb(void *data, Eo *view, + const Eo_Event_Description *desc EINA_UNUSED, + void *event_info EINA_UNUSED) +{ + Term *term = data; + const char *id = NULL; + + if (term) + { + Evas_Object *term_object; + + term_object = main_term_evas_object_get(term); + evas_object_data_del(term_object, "app_view"); + main_close(main_win_evas_object_get(main_term_win_get(term)), + term_object); + } + + eo_do(view, id = elm_app_server_view_id_get()); + terminology_item_term_entries_del(views_eet, id); + + eo_del(view); + return EINA_TRUE; +} + +static void +_term_title_changed_cb(void *data, Evas_Object *obj, + void *event_info EINA_UNUSED) +{ + const char *title = termio_title_get(obj); + eo_do(data, elm_app_server_view_title_set(title)); +} + +static void +_term_icon_changed_cb(void *data, Evas_Object *obj, + void *event_info EINA_UNUSED) +{ + const char *icon = termio_icon_name_get(obj); + eo_do(data, elm_app_server_view_icon_set(icon)); +} + +static Eina_Bool +_view_save_cb(void *data EINA_UNUSED, + Eo *view, + const Eo_Event_Description *desc EINA_UNUSED, + void *event_info EINA_UNUSED) +{ + char dir[PATH_MAX]; + Evas_Object *term_object; + const char *id = NULL; + Term_Item *term_eet; + + term_object = main_term_evas_object_get(data); + + /* + * if we call elm_app_server_save() in some case that the terminology + * will continue run, this data_del will lead to issues. + */ + evas_object_data_del(term_object, "app_view"); + + termio_cwd_get(term_object, dir, sizeof(dir)); + eo_do(view, id = elm_app_server_view_id_get()); + + term_eet = terminology_item_term_entries_get(views_eet, id); + if (term_eet) + { + term_item_dir_set(term_eet, dir); + return EINA_TRUE; + } + + term_eet = term_item_new(id, dir); + terminology_item_term_entries_add(views_eet, id, term_eet); + + return EINA_TRUE; +} + +static Eina_Bool +_view_resumed_cb(void *data, Eo *view, + const Eo_Event_Description *desc EINA_UNUSED, + void *event_info EINA_UNUSED) +{ + Term *term = data; + Win *wn; + Eina_List **wins = NULL; + const char *title, *id = NULL; + Evas_Object *term_object; + const char *dir = NULL; + Term_Item *term_eet; + + if (term) + { + main_term_focus(term); + return EINA_TRUE; + } + + eo_do(_server, wins = eo_key_data_get("wins")); + if (!wins || !(wn = eina_list_data_get(*wins))) + { + ERR("There is no window open"); + return EINA_TRUE; + } + + term = eina_list_data_get(main_win_terms_get(wn)); + + eo_do(view, id = elm_app_server_view_id_get()); + term_eet = terminology_item_term_entries_get(views_eet, id); + if (term_eet) + { + dir = term_item_dir_get(term_eet); + //not valid data saved + if (!dir || dir[0] != '/') + { + terminology_item_term_entries_del(views_eet, id); + dir = NULL; + } + } + + _ignore_term_add = EINA_TRUE; + if (dir) + main_new_with_dir(main_win_evas_object_get(wn), + main_term_evas_object_get(term), dir); + else + main_new(main_win_evas_object_get(wn), main_term_evas_object_get(term)); + _ignore_term_add = EINA_FALSE; + + //just add term + term = eina_list_last_data_get(main_win_terms_get(wn)); + term_object = main_term_evas_object_get(term); + title = termio_title_get(term_object); + + evas_object_data_set(term_object, "app_view", view); + + eo_do(view, elm_app_server_view_title_set(title), + elm_app_server_view_window_set( + main_win_evas_object_get(main_term_win_get(term))), + eo_event_callback_del(ELM_APP_SERVER_VIEW_EVENT_CLOSED, _view_closed_cb, + NULL), + eo_event_callback_del(ELM_APP_SERVER_VIEW_EVENT_RESUMED, _view_resumed_cb, + NULL), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_CLOSED, _view_closed_cb, + term), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_RESUMED, _view_resumed_cb, + term), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_SAVE, _view_save_cb, + term)); + + evas_object_smart_callback_add(term_object, "title,change", + _term_title_changed_cb, view); + evas_object_smart_callback_add(term_object, "icon,change", + _term_icon_changed_cb, term); + + return EINA_TRUE; +} + +static Eina_Bool +_server_terminate_cb(void *data, Eo *obj EINA_UNUSED, + const Eo_Event_Description *desc EINA_UNUSED, + void *event_info EINA_UNUSED) +{ + Eina_List **wins = data, *l, *l2; + Win *wn; + + EINA_LIST_FOREACH_SAFE(*wins, l, l2, wn) + evas_object_del(main_win_evas_object_get(wn)); + + return EINA_TRUE; +} + +void +app_server_shutdown(void) +{ + char lock_file[PATH_MAX]; + + if (!_server) + return; + + _user_config_file_path_build(lock_file, sizeof(lock_file), ".lock"); + ecore_file_remove(lock_file); + + eo_do(_server, elm_app_server_save()); + + if (views_eet) + { + char eet_dir[PATH_MAX]; + + _user_config_file_path_build(eet_dir, sizeof(eet_dir), "terms.eet"); + terminology_item_save(views_eet, eet_dir); + + terminology_item_free(views_eet); + } + app_server_eet_shutdown(); + + eo_unref(_server); + _server = NULL; +} + +void +app_server_win_del_request_cb(void *data EINA_UNUSED, + Evas_Object *obj EINA_UNUSED, + void *event_info EINA_UNUSED) +{ + Eina_List **wins = NULL; + + if (!_server) + return; + + eo_do(_server, wins = eo_key_data_get("wins")); + + if (wins && eina_list_count(*wins) > 1) + return; + + /* + * this way the terms of view are already alive + * and we can get pwd and backlog + */ + app_server_shutdown(); +} + +static Elm_App_Server_View * +_app_server_term_add(Term *term) +{ + Elm_App_Server_View *view; + const char *title; + Evas_Object *term_object; + + if (_ignore_term_add) + return NULL; + + view = eo_add(ELM_APP_SERVER_VIEW_CLASS, _server, + elm_app_server_view_constructor(NULL)); + + term_object = main_term_evas_object_get(term); + + title = termio_title_get(term_object); + + eo_do(view, elm_app_server_view_title_set(title), + elm_app_server_view_window_set( + main_win_evas_object_get(main_term_win_get(term))), + elm_app_server_view_resume(), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_CLOSED, + _view_closed_cb, term), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_RESUMED, + _view_resumed_cb, term), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_SAVE, + _view_save_cb, term)); + + evas_object_smart_callback_add(term_object, "title,change", + _term_title_changed_cb, view); + evas_object_smart_callback_add(term_object, "icon,change", + _term_icon_changed_cb, term); + evas_object_data_set(term_object, "app_view", view); + + return view; +} + +void +app_server_term_add(Term *term) +{ + Elm_App_Server_View *view; + + if (!_server) + return; + + view = _app_server_term_add(term); + if (!view) + return; + + eo_do(_server, elm_app_server_view_add(view)); +} + +static Elm_App_Server_View * +_app_server_create_view_cb(Elm_App_Server *server, const Eina_Value *args EINA_UNUSED, + Eina_Stringshare **error_name, + Eina_Stringshare **error_message EINA_UNUSED) +{ + Win *wn; + Term *term; + Eina_List **wins = NULL; + + eo_do(server, wins = eo_key_data_get("wins")); + if (!wins || !(wn = eina_list_data_get(*wins))) + { + *error_name = eina_stringshare_add(_("There is no window open")); + ERR("%s", *error_name); + return NULL; + } + term = eina_list_data_get(main_win_terms_get(wn)); + + _ignore_term_add = EINA_TRUE; + main_new(main_win_evas_object_get(wn), main_term_evas_object_get(term)); + _ignore_term_add = EINA_FALSE; + + //Term just added by main_new() + term = eina_list_last_data_get(main_win_terms_get(wn)); + + return _app_server_term_add(term); +} + +static Eina_Bool +_restore_view_cb(void *data) +{ + Elm_App_Server_View *view = data; + eo_do(view, elm_app_server_view_resume()); + return EINA_FALSE; +} + +void +app_server_init(Eina_List **wins, Eina_Bool restore_views) +{ + Win *wn; + Eina_Iterator *views = NULL; + Elm_App_Server_View *view; + const char *title; + char lock_file[PATH_MAX], eet_dir[PATH_MAX]; + FILE *f; + + if (!wins) + return; + wn = eina_list_data_get(*wins); + if (!wn) + return; + + //we only can have one instance of Terminology running app_server + _user_config_file_path_build(lock_file, sizeof(lock_file), ".lock"); + if (ecore_file_exists(lock_file)) + return; + + //create lock file + f = fopen(lock_file, "w"); + if (!f) + return; + fprintf(f, "locked"); + fclose(f); + + app_server_eet_init(); + _user_config_file_path_build(eet_dir, sizeof(eet_dir), "terms.eet"); + views_eet = terminology_item_load(eet_dir); + if (!views_eet) + views_eet = terminology_item_new(1); + + title = elm_win_title_get(main_win_evas_object_get(wn)); + + + _server = eo_add(ELM_APP_SERVER_CLASS, NULL, + elm_app_server_constructor( + "org.enlightenment.Terminology", + _app_server_create_view_cb)); + + eo_do(_server, elm_app_server_title_set(title), + eo_key_data_set("wins", wins, NULL), + views = elm_app_server_views_get(), + eo_event_callback_add(ELM_APP_SERVER_EVENT_TERMINATE, + _server_terminate_cb, wins)); + //views saved + EINA_ITERATOR_FOREACH(views, view) + { + if (restore_views) + ecore_idler_add(_restore_view_cb, view); + eo_do(view, + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_CLOSED, + _view_closed_cb, NULL), + eo_event_callback_add(ELM_APP_SERVER_VIEW_EVENT_RESUMED, + _view_resumed_cb, NULL)); + } + eina_iterator_free(views); +} + + +#else + +void app_server_init(Eina_List **wins EINA_UNUSED, + Eina_Bool restore_views EINA_UNUSED) {} +void app_server_shutdown(void) {} +void app_server_term_add(Term *term EINA_UNUSED) {} +void app_server_term_del(Evas_Object *term EINA_UNUSED) {} +void app_server_win_del_request_cb(void *data EINA_UNUSED, + Evas_Object *obj EINA_UNUSED, + void *event_info EINA_UNUSED) {} + +#endif diff --git a/src/bin/app_server.h b/src/bin/app_server.h new file mode 100644 index 00000000..8b368513 --- /dev/null +++ b/src/bin/app_server.h @@ -0,0 +1,11 @@ +#ifndef _APP_SERVER_H__ +#define _APP_SERVER_H__ 1 + + +void app_server_init(Eina_List **wins, Eina_Bool restore_views); +void app_server_shutdown(void); +void app_server_term_add(Term *term); +void app_server_term_del(Evas_Object *term); +void app_server_win_del_request_cb(void *data, Evas_Object *obj, void *event_info); + +#endif diff --git a/src/bin/app_server_eet.c b/src/bin/app_server_eet.c new file mode 100644 index 00000000..ef6d0c7c --- /dev/null +++ b/src/bin/app_server_eet.c @@ -0,0 +1,252 @@ +#include +#include +#include +#include +#include + +#include "app_server_eet.h" + +struct _Term_Item { + const char * id; + const char * dir; +}; + +struct _Terminology_Item { + unsigned int version; + Eina_Hash * term_entries; + const char *__eet_filename; +}; + +static const char TERM_ITEM_ENTRY[] = "term_item"; +static const char TERMINOLOGY_ITEM_ENTRY[] = "terminology_item"; + +static Eet_Data_Descriptor *_term_item_descriptor = NULL; +static Eet_Data_Descriptor *_terminology_item_descriptor = NULL; + +static void +_term_item_init(void) +{ + Eet_Data_Descriptor_Class eddc; + + if (_term_item_descriptor) return; + + EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Term_Item); + _term_item_descriptor = eet_data_descriptor_stream_new(&eddc); + + EET_DATA_DESCRIPTOR_ADD_BASIC(_term_item_descriptor, Term_Item, "id", id, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(_term_item_descriptor, Term_Item, "dir", dir, EET_T_STRING); +} + +static void +_term_item_shutdown(void) +{ + if (!_term_item_descriptor) return; + eet_data_descriptor_free(_term_item_descriptor); + _term_item_descriptor = NULL; +} + +Term_Item * +term_item_new(const char * id, const char * dir) +{ + Term_Item *term_item = calloc(1, sizeof(Term_Item)); + + if (!term_item) + { + fprintf(stderr, "ERROR: could not calloc Term_Item\n"); + return NULL; + } + + term_item->id = eina_stringshare_add(id ? id : ""); + term_item->dir = eina_stringshare_add(dir ? dir : "/"); + + return term_item; +} + +void +term_item_free(Term_Item *term_item) +{ + eina_stringshare_del(term_item->id); + eina_stringshare_del(term_item->dir); + free(term_item); +} + +const char * +term_item_id_get(const Term_Item *term_item) +{ + return term_item->id; +} + +void +term_item_id_set(Term_Item *term_item, const char *id) +{ + EINA_SAFETY_ON_NULL_RETURN(term_item); + eina_stringshare_replace(&(term_item->id), id); +} + +const char * +term_item_dir_get(const Term_Item *term_item) +{ + return term_item->dir; +} + +void +term_item_dir_set(Term_Item *term_item, const char *dir) +{ + EINA_SAFETY_ON_NULL_RETURN(term_item); + eina_stringshare_replace(&(term_item->dir), dir); +} + + +static void +_terminology_item_init(void) +{ + Eet_Data_Descriptor_Class eddc; + + if (_terminology_item_descriptor) return; + + EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Terminology_Item); + _terminology_item_descriptor = eet_data_descriptor_stream_new(&eddc); + + EET_DATA_DESCRIPTOR_ADD_BASIC(_terminology_item_descriptor, Terminology_Item, "version", version, EET_T_UINT); + EET_DATA_DESCRIPTOR_ADD_HASH(_terminology_item_descriptor, Terminology_Item, "term_entries", term_entries, _term_item_descriptor); +} + +static void +_terminology_item_shutdown(void) +{ + if (!_terminology_item_descriptor) return; + eet_data_descriptor_free(_terminology_item_descriptor); + _terminology_item_descriptor = NULL; +} + +Terminology_Item * +terminology_item_new(unsigned int version) +{ + Terminology_Item *terminology_item = calloc(1, sizeof(Terminology_Item)); + + if (!terminology_item) + { + fprintf(stderr, "ERROR: could not calloc Terminology_Item\n"); + return NULL; + } + + terminology_item->version = version; + terminology_item->term_entries = eina_hash_stringshared_new(EINA_FREE_CB(term_item_free)); + + return terminology_item; +} + +void +terminology_item_free(Terminology_Item *terminology_item) +{ + if (terminology_item->term_entries) eina_hash_free(terminology_item->term_entries); + free(terminology_item); +} + +unsigned int +terminology_item_version_get(const Terminology_Item *terminology_item) +{ + return terminology_item->version; +} + +void +terminology_item_version_set(Terminology_Item *terminology_item, unsigned int version) +{ + EINA_SAFETY_ON_NULL_RETURN(terminology_item); + terminology_item->version = version; +} + +void +terminology_item_term_entries_add(Terminology_Item *terminology_item, const char * id, Term_Item *term_item) +{ + EINA_SAFETY_ON_NULL_RETURN(terminology_item); + eina_hash_add(terminology_item->term_entries, id, term_item); +} + +void +terminology_item_term_entries_del(Terminology_Item *terminology_item, const char * id) +{ + EINA_SAFETY_ON_NULL_RETURN(terminology_item); + eina_hash_del(terminology_item->term_entries, id, NULL); +} + +Term_Item * +terminology_item_term_entries_get(const Terminology_Item *terminology_item, const char * id) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(terminology_item, NULL); + return eina_hash_find(terminology_item->term_entries, id); +} + +Eina_Hash * +terminology_item_term_entries_hash_get(const Terminology_Item *terminology_item) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(terminology_item, NULL); + return terminology_item->term_entries; +} + +void +terminology_item_term_entries_modify(Terminology_Item *terminology_item, const char * key, void *value) +{ + EINA_SAFETY_ON_NULL_RETURN(terminology_item); + eina_hash_modify(terminology_item->term_entries, key, value); +} + +Terminology_Item * +terminology_item_load(const char *filename) +{ + Terminology_Item *terminology_item = NULL; + Eet_File *ef = eet_open(filename, EET_FILE_MODE_READ); + if (!ef) + { + fprintf(stderr, "ERROR: could not open '%s' for read\n", filename); + return NULL; + } + + terminology_item = eet_data_read(ef, _terminology_item_descriptor, TERMINOLOGY_ITEM_ENTRY); + if (!terminology_item) goto end; + terminology_item->__eet_filename = eina_stringshare_add(filename); + + if (!terminology_item->term_entries) terminology_item->term_entries = eina_hash_stringshared_new(EINA_FREE_CB(term_item_free)); + +end: + eet_close(ef); + return terminology_item; +} + +Eina_Bool +terminology_item_save(Terminology_Item *terminology_item, const char *filename) +{ + Eet_File *ef; + Eina_Bool ret; + + if (filename) eina_stringshare_replace(&(terminology_item->__eet_filename), filename); + else if (terminology_item->__eet_filename) filename = terminology_item->__eet_filename; + else return EINA_FALSE; + + ef = eet_open(filename, EET_FILE_MODE_READ_WRITE); + if (!ef) + { + fprintf(stderr, "ERROR: could not open '%s' for write\n", filename); + return EINA_FALSE; + } + + ret = !!eet_data_write(ef, _terminology_item_descriptor, TERMINOLOGY_ITEM_ENTRY, terminology_item, EINA_TRUE); + eet_close(ef); + + return ret; +} + +void +app_server_eet_init(void) +{ + _term_item_init(); + _terminology_item_init(); +} + +void +app_server_eet_shutdown(void) +{ + _term_item_shutdown(); + _terminology_item_shutdown(); +} + diff --git a/src/bin/app_server_eet.h b/src/bin/app_server_eet.h new file mode 100644 index 00000000..968871a3 --- /dev/null +++ b/src/bin/app_server_eet.h @@ -0,0 +1,38 @@ +#ifndef _APP_SERVER_EET_H__ +#define _APP_SERVER_EET_H__ 1 + +#include +#include + +typedef struct _Term_Item Term_Item; +typedef struct _Terminology_Item Terminology_Item; + +/* Term_Item */ +Term_Item *term_item_new(const char * id, const char * dir); +void term_item_free(Term_Item *term_item); + +void term_item_id_set(Term_Item *term_item, const char * id); +const char * term_item_id_get(const Term_Item *term_item); +void term_item_dir_set(Term_Item *term_item, const char * dir); +const char * term_item_dir_get(const Term_Item *term_item); + +/* Terminology_Item */ +Terminology_Item *terminology_item_new(unsigned int version); +void terminology_item_free(Terminology_Item *terminology_item); + +void terminology_item_version_set(Terminology_Item *terminology_item, unsigned int version); +unsigned int terminology_item_version_get(const Terminology_Item *terminology_item); +void terminology_item_term_entries_add(Terminology_Item *terminology_item, const char * id, Term_Item *term_item); +void terminology_item_term_entries_del(Terminology_Item *terminology_item, const char * id); +Term_Item *terminology_item_term_entries_get(const Terminology_Item *terminology_item, const char * key); +Eina_Hash *terminology_item_term_entries_hash_get(const Terminology_Item *terminology_item); +void terminology_item_term_entries_modify(Terminology_Item *terminology_item, const char * key, void *value); + +Terminology_Item *terminology_item_load(const char *filename); +Eina_Bool terminology_item_save(Terminology_Item *terminology_item, const char *filename); + +/* Global initializer / shutdown functions */ +void app_server_eet_init(void); +void app_server_eet_shutdown(void); + +#endif /* _APP_SERVER_EET_H__ */ diff --git a/src/bin/config.c b/src/bin/config.c index 8ff4b496..948b13ae 100644 --- a/src/bin/config.c +++ b/src/bin/config.c @@ -142,6 +142,11 @@ config_init(void) (edd_base, Config, "drag_links", drag_links, EET_T_UCHAR); EET_DATA_DESCRIPTOR_ADD_BASIC (edd_base, Config, "login_shell", login_shell, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC + (edd_base, Config, "application_server", application_server, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC + (edd_base, Config, "application_server_restore_views", + application_server_restore_views, EET_T_UCHAR); EET_DATA_DESCRIPTOR_ADD_BASIC (edd_base, Config, "mouse_over_focus", mouse_over_focus, EET_T_UCHAR); @@ -242,6 +247,8 @@ config_sync(const Config *config_src, Config *config) config->visualize = config_src->visualize; config->urg_bell = config_src->urg_bell; config->multi_instance = config_src->multi_instance; + config->application_server = config_src->application_server; + config->application_server_restore_views = config_src->application_server_restore_views; config->xterm_256color = config_src->xterm_256color; config->erase_is_del = config_src->erase_is_del; config->temporary = config_src->temporary; @@ -513,6 +520,8 @@ config_load(const char *key) config->visualize = EINA_TRUE; config->urg_bell = EINA_TRUE; config->multi_instance = EINA_FALSE; + config->application_server = EINA_FALSE; + config->application_server_restore_views = EINA_FALSE; config->xterm_256color = EINA_FALSE; config->erase_is_del = EINA_FALSE; config->custom_geometry = EINA_FALSE; @@ -596,6 +605,8 @@ config_fork(Config *config) CPY(visualize); CPY(urg_bell); CPY(multi_instance); + CPY(application_server); + CPY(application_server_restore_views); CPY(xterm_256color); CPY(erase_is_del); CPY(custom_geometry); diff --git a/src/bin/config.h b/src/bin/config.h index c4e69553..0b489884 100644 --- a/src/bin/config.h +++ b/src/bin/config.h @@ -63,6 +63,8 @@ struct _Config Eina_Bool visualize; Eina_Bool urg_bell; Eina_Bool multi_instance; + Eina_Bool application_server; + Eina_Bool application_server_restore_views; Eina_Bool xterm_256color; Eina_Bool erase_is_del; Eina_Bool custom_geometry; diff --git a/src/bin/main.c b/src/bin/main.c index 1ae0682c..7372ee49 100644 --- a/src/bin/main.c +++ b/src/bin/main.c @@ -15,6 +15,7 @@ #include "utils.h" #include "ipc.h" #include "sel.h" +#include "app_server.h" #include "dbus.h" #include "miniview.h" #include "gravatar.h" @@ -848,6 +849,10 @@ remote: } config = win_config_get(wn); +#if 0 + if (config->application_server) + app_server_init(&wins, config->application_server_restore_views); +#endif term = term_new(wn, config, cmd, login_shell, cd, size_w, size_h, hold); @@ -918,6 +923,8 @@ remote: elm_run(); + app_server_shutdown(); + ty_dbus_shutdown(); config = NULL; end: diff --git a/src/bin/options_behavior.c b/src/bin/options_behavior.c index 1ca624ee..4d5c5d0c 100644 --- a/src/bin/options_behavior.c +++ b/src/bin/options_behavior.c @@ -43,6 +43,67 @@ CB(hide_top_tabbar, 0); #undef CB + +/* +static void +_cb_op_behavior_application_server_restore_views_chg(void *data, Evas_Object *obj, + void *event EINA_UNUSED) +{ + Evas_Object *term = data; + Config *config = termio_config_get(term); + config->application_server_restore_views = elm_check_state_get(obj); + config_save(config, NULL); +} + +static void +_behavior_option_restore_opened_views_add(Evas_Object *term, + Evas_Object *check) +{ + Evas_Object *bx = evas_object_data_get(check, "box"); + Evas_Object *o; + Config *config = termio_config_get(term); + + o = elm_check_add(bx); + evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, 0.0); + evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.5); + elm_object_text_set(o, _("Restore opened views")); + elm_check_state_set(o, config->application_server_restore_views); + elm_box_pack_after(bx, o, check); + evas_object_show(o); + evas_object_data_set(check, "restore_views", o); + evas_object_smart_callback_add(o, "changed", + _cb_op_behavior_application_server_restore_views_chg, + term); +} + + +static void +_behavior_option_restore_opened_views_del(Evas_Object *check) +{ + Evas_Object *o = evas_object_data_del(check, "restore_views"); + if (o) + evas_object_del(o); +} + +static void +_cb_op_behavior_application_server(void *data, Evas_Object *obj, void *event EINA_UNUSED) +{ + Evas_Object *term = data; + Config *config = termio_config_get(term); + Eina_Bool old = config->application_server; + config->application_server = elm_check_state_get(obj); + + if (old == config->application_server) + return; + + if (!config->application_server) + _behavior_option_restore_opened_views_del(obj); + else + _behavior_option_restore_opened_views_add(term, obj); + config_save(config, NULL); +} +*/ + static unsigned int sback_double_to_expo_int(double d) { @@ -189,8 +250,16 @@ options_behavior(Evas_Object *opbox, Evas_Object *term) CX(_("Gravatar integration"), gravatar, 0); CX(_("Hide top tab bar on launch"), hide_top_tabbar, 0); +/* + CX(_("Enable application server"), application_server, 0); + + evas_object_data_set(o, "box", bx); + if (config->application_server) + _behavior_option_restore_opened_views_add(term, o); + */ #undef CX + o = elm_check_add(bx); evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, 0.0); evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.5); diff --git a/src/bin/win.c b/src/bin/win.c index 30ef246b..1c6c4ba2 100644 --- a/src/bin/win.c +++ b/src/bin/win.c @@ -6,6 +6,7 @@ #include "main.h" #include "miniview.h" #include "gravatar.h" +#include "app_server.h" #include "media.h" #include "termio.h" #include "utils.h" @@ -741,6 +742,9 @@ tg_win_add(const char *name, const char *role, const char *title, const char *ic elm_win_icon_name_set(win, icon_name); if (role) elm_win_role_set(win, role); + evas_object_smart_callback_add(win, "delete,request", + app_server_win_del_request_cb, win); + elm_win_autodel_set(win, EINA_TRUE); o = evas_object_image_add(evas_object_evas_get(win)); @@ -1000,6 +1004,8 @@ main_close(Evas_Object *win, Evas_Object *term) if (!wn) return; + app_server_term_del(term); + tm = evas_object_data_get(term, "term"); if (!tm) return; @@ -4244,6 +4250,7 @@ term_new(Win *wn, Config *config, const char *cmd, _cb_term_mouse_in, term); wn->terms = eina_list_append(wn->terms, term); + app_server_term_add(term); return term; }