enlightenment/terminology
enlightenment
/
terminology
9
6
Fork 7
Code Issues 7 Pull Requests 1 Projects Releases Wiki Activity

remove app server dead code

This commit is contained in:
Boris Faure 2014-12-13 12:30:55 +01:00
parent d93a54b278
commit 3ffcbadd6f
12 changed files with 0 additions and 846 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Marrakesh.mrk
View File

@ -21,10 +21,6 @@ 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

2
po/POTFILES.in
View File

@ -1,7 +1,5 @@
src/bin/controls.c
src/bin/about.c
src/bin/app_server.c
src/bin/app_server_eet.c
src/bin/col.c
src/bin/config.c
src/bin/controls.c

2
src/bin/Makefile.am
View File

@ -56,8 +56,6 @@ win.c win.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

442
src/bin/app_server.c
View File

@ -1,442 +0,0 @@
#include "private.h"
#include <Elementary.h>
#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

11
src/bin/app_server.h
View File

@ -1,11 +0,0 @@
#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

252
src/bin/app_server_eet.c
View File

@ -1,252 +0,0 @@
#include <limits.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#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();
}

38
src/bin/app_server_eet.h
View File

@ -1,38 +0,0 @@
#ifndef _APP_SERVER_EET_H__
#define _APP_SERVER_EET_H__ 1
#include <Eina.h>
#include <Eet.h>
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__ */

11
src/bin/config.c
View File

@ -142,11 +142,6 @@ 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);
@ -247,8 +242,6 @@ 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;
@ -520,8 +513,6 @@ 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;
@ -605,8 +596,6 @@ 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);

2
src/bin/config.h
View File

@ -63,8 +63,6 @@ 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;

7
src/bin/main.c
View File

@ -15,7 +15,6 @@
#include "utils.h"
#include "ipc.h"
#include "sel.h"
#include "app_server.h"
#include "dbus.h"
#include "miniview.h"
#include "gravatar.h"
@ -852,10 +851,6 @@ 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);
@ -926,8 +921,6 @@ remote:
elm_run();
app_server_shutdown();
ty_dbus_shutdown();
config = NULL;
end:

68
src/bin/options_behavior.c
View File

@ -44,67 +44,6 @@ CB(notabs, 1);
#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)
{
@ -251,13 +190,6 @@ options_behavior(Evas_Object *opbox, Evas_Object *term)
CX(_("Gravatar integration"), gravatar, 0);
CX(_("Show tabs"), notabs, 1);
/*
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

7
src/bin/win.c
View File

@ -5,7 +5,6 @@
#include "main.h"
#include "miniview.h"
#include "gravatar.h"
#include "app_server.h"
#include "media.h"
#include "termio.h"
#include "utils.h"
@ -437,9 +436,6 @@ 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));
@ -520,8 +516,6 @@ main_close(Evas_Object *win, Evas_Object *term)
const char *slot = PANES_TOP;
Eina_Bool term_was_focused;
app_server_term_del(term);
if (!sp) return;
if (!sp->term) return;
if (!tm) return;
@ -2730,7 +2724,6 @@ term_new(Win *wn, Config *config, const char *cmd,
if (!wn->terms) term->focused = EINA_TRUE;
wn->terms = eina_list_append(wn->terms, term);
app_server_term_add(term);
return term;
}