enlightenment/ecrire
enlightenment
/
ecrire
6
0
Fork 1
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Ecrire: Finally get around to making an object per entry. 

Will be used for easier context passing and possibly tab support in the
future.

SVN revision: 67498
This commit is contained in:
Tom Hacohen 2012-01-24 15:12:42 +00:00
parent ed90523aeb
commit 19c93f76e3
6 changed files with 236 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

371
src/bin/main.c
View File

@ -17,28 +17,19 @@
#include "ui/ui.h"
static Eina_Unicode plain_utf8 = EINA_TRUE;
static Evas_Object *entry;
static const char *filename = NULL;
static int unsaved = 1;
static Elm_Object_Item *copy_item, *cut_item, *save_item, *paste_item, *undo_item, *redo_item;
/* Undo stack */
static Eina_List *undo_stack;
static Eina_List *undo_stack_ptr;
static Eina_List *last_saved_stack_ptr = NULL;
static Eina_Bool undo_stack_can_merge = EINA_FALSE;
static Ecrire_Entry *main_ec_ent;
static void print_usage(const char *bin);
static void editor_font_set(Evas_Object *ent, const char *font, int font_size);
static void editor_font_set(Ecrire_Entry *ent, const char *font, int font_size);
static void
_init_entry(Evas_Object *ent)
_init_entry(Ecrire_Entry *ent)
{
Elm_Entry_Change_Info *inf;
editor_font_set(ent, _ent_cfg->font.name, _ent_cfg->font.size);
/* Init the undo stack */
EINA_LIST_FREE(undo_stack, inf)
EINA_LIST_FREE(ent->undo_stack, inf)
{
if (inf)
{
@ -53,56 +44,62 @@ _init_entry(Evas_Object *ent)
free(inf);
}
}
undo_stack = undo_stack_ptr = eina_list_append(undo_stack, NULL);
last_saved_stack_ptr = undo_stack_ptr;
ent->undo_stack = ent->undo_stack_ptr =
eina_list_append(ent->undo_stack, NULL);
ent->last_saved_stack_ptr = ent->undo_stack_ptr;
ent->undo_stack_can_merge = EINA_FALSE;
elm_object_item_disabled_set(undo_item, EINA_TRUE);
elm_object_item_disabled_set(redo_item, EINA_TRUE);
elm_object_item_disabled_set(ent->undo_item, EINA_TRUE);
elm_object_item_disabled_set(ent->redo_item, EINA_TRUE);
}
static void
_alert_if_need_saving(void (*done)(void *data), void *data)
_alert_if_need_saving(void (*done)(void *data), Ecrire_Entry *ent)
{
if (!elm_object_item_disabled_get(save_item))
if (!elm_object_item_disabled_get(ent->save_item))
{
ui_alert_need_saving(done, data);
ui_alert_need_saving(ent->entry, done, ent);
}
else
{
done(data);
done(ent);
}
}
static void
_sel_start(void *data __UNUSED__, Evas_Object *obj __UNUSED__,
_sel_start(void *data, Evas_Object *obj __UNUSED__,
void *event_info __UNUSED__)
{
elm_object_item_disabled_set(copy_item, EINA_FALSE);
elm_object_item_disabled_set(cut_item, EINA_FALSE);
Ecrire_Entry *ent = data;
elm_object_item_disabled_set(ent->copy_item, EINA_FALSE);
elm_object_item_disabled_set(ent->cut_item, EINA_FALSE);
}
static void
_sel_clear(void *data __UNUSED__, Evas_Object *obj __UNUSED__,
void *event_info __UNUSED__)
{
elm_object_item_disabled_set(copy_item, EINA_TRUE);
elm_object_item_disabled_set(cut_item, EINA_TRUE);
Ecrire_Entry *ent = data;
elm_object_item_disabled_set(ent->copy_item, EINA_TRUE);
elm_object_item_disabled_set(ent->cut_item, EINA_TRUE);
}
static void
_update_cur_file(const char *file, Evas_Object *win)
_update_cur_file(const char *file, Ecrire_Entry *ent)
{
const char *saving = (!elm_object_item_disabled_get(save_item)) ? "*" : "";
eina_stringshare_replace(&filename, file);
const char *saving = (!elm_object_item_disabled_get(ent->save_item)) ?
"*" : "";
eina_stringshare_replace(&ent->filename, file);
{
char buf[1024];
if (filename)
snprintf(buf, sizeof(buf), _("%s%s - %s"), saving, filename, PACKAGE_NAME);
else
snprintf(buf, sizeof(buf), _("%sUntitled %d - %s"), saving, unsaved,
if (ent->filename)
snprintf(buf, sizeof(buf), _("%s%s - %s"), saving, ent->filename,
PACKAGE_NAME);
else
snprintf(buf, sizeof(buf), _("%sUntitled %d - %s"), saving,
ent->unsaved, PACKAGE_NAME);
elm_win_title_set(win, buf);
elm_win_title_set(ent->win, buf);
}
}
@ -128,39 +125,42 @@ _cur_changed(void *data, Evas_Object *obj, void *event_info __UNUSED__)
}
static void
_cur_changed_manual(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
_cur_changed_manual(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
undo_stack_can_merge = EINA_FALSE;
Ecrire_Entry *ent = data;
ent->undo_stack_can_merge = EINA_FALSE;
}
static void
_update_undo_redo_items(Evas_Object *ent)
_update_undo_redo_items(Ecrire_Entry *ent)
{
elm_object_item_disabled_set(undo_item, !eina_list_next(undo_stack_ptr));
elm_object_item_disabled_set(redo_item, !eina_list_prev(undo_stack_ptr));
elm_object_item_disabled_set(ent->undo_item,
!eina_list_next(ent->undo_stack_ptr));
elm_object_item_disabled_set(ent->redo_item,
!eina_list_prev(ent->undo_stack_ptr));
if (undo_stack_ptr == last_saved_stack_ptr)
if (ent->undo_stack_ptr == ent->last_saved_stack_ptr)
{
elm_object_item_disabled_set(save_item, EINA_TRUE);
_update_cur_file(filename, elm_object_top_widget_get(ent));
elm_object_item_disabled_set(ent->save_item, EINA_TRUE);
_update_cur_file(ent->filename, ent);
}
else if (elm_object_item_disabled_get(save_item))
else if (elm_object_item_disabled_get(ent->save_item))
{
elm_object_item_disabled_set(save_item, EINA_FALSE);
_update_cur_file(filename, elm_object_top_widget_get(ent));
elm_object_item_disabled_set(ent->save_item, EINA_FALSE);
_update_cur_file(ent->filename, ent);
}
}
static void
_undo_stack_add(Elm_Entry_Change_Info *_info)
_undo_stack_add(Ecrire_Entry *ent, Elm_Entry_Change_Info *_info)
{
Elm_Entry_Change_Info *inf;
undo_stack = eina_list_split_list(undo_stack, eina_list_prev(undo_stack_ptr),
&undo_stack_ptr);
ent->undo_stack = eina_list_split_list(ent->undo_stack, eina_list_prev(ent->undo_stack_ptr),
&ent->undo_stack_ptr);
EINA_LIST_FREE(undo_stack, inf)
EINA_LIST_FREE(ent->undo_stack, inf)
{
if (inf->insert)
{
@ -184,7 +184,7 @@ _undo_stack_add(Elm_Entry_Change_Info *_info)
else
#endif
{
Elm_Entry_Change_Info *head_inf = eina_list_data_get(undo_stack_ptr);
Elm_Entry_Change_Info *head_inf = eina_list_data_get(ent->undo_stack_ptr);
inf = calloc(1, sizeof(*inf));
memcpy(inf, _info, sizeof(*inf));
@ -197,54 +197,54 @@ _undo_stack_add(Elm_Entry_Change_Info *_info)
eina_stringshare_ref(inf->change.del.content);
}
if (undo_stack_can_merge && (inf->insert == head_inf->insert))
if (ent->undo_stack_can_merge && (inf->insert == head_inf->insert))
inf->merge = EINA_TRUE;
undo_stack_ptr = eina_list_prepend(undo_stack_ptr, inf);
ent->undo_stack_ptr = eina_list_prepend(ent->undo_stack_ptr, inf);
}
undo_stack = undo_stack_ptr;
ent->undo_stack = ent->undo_stack_ptr;
undo_stack_can_merge = EINA_TRUE;
ent->undo_stack_can_merge = EINA_TRUE;
_update_undo_redo_items(entry);
_update_undo_redo_items(ent);
}
static void
_undo_redo_do(Evas_Object *ent, Elm_Entry_Change_Info *inf, Eina_Bool undo)
_undo_redo_do(Ecrire_Entry *ent, Elm_Entry_Change_Info *inf, Eina_Bool undo)
{
EINA_LOG_DBG("%s: %s", (undo) ? "Undo" : "Redo",
inf->change.insert.content);
if ((inf->insert && undo) || (!inf->insert && !undo))
{
const Evas_Object *tb = elm_entry_textblock_get(ent);
const Evas_Object *tb = elm_entry_textblock_get(ent->entry);
Evas_Textblock_Cursor *mcur, *end;
mcur = (Evas_Textblock_Cursor *) evas_object_textblock_cursor_get(tb);
end = evas_object_textblock_cursor_new(tb);
if (inf->insert)
{
elm_entry_cursor_pos_set(ent, inf->change.insert.pos);
elm_entry_cursor_pos_set(ent->entry, inf->change.insert.pos);
evas_textblock_cursor_pos_set(end, inf->change.insert.pos +
inf->change.insert.plain_length);
}
else
{
elm_entry_cursor_pos_set(ent, inf->change.del.start);
elm_entry_cursor_pos_set(ent->entry, inf->change.del.start);
evas_textblock_cursor_pos_set(end, inf->change.del.end);
}
evas_textblock_cursor_range_delete(mcur, end);
evas_textblock_cursor_free(end);
elm_entry_calc_force(ent);
elm_entry_calc_force(ent->entry);
}
else
{
if (inf->insert)
{
elm_entry_cursor_pos_set(ent, inf->change.insert.pos);
elm_entry_entry_insert(ent, inf->change.insert.content);
elm_entry_cursor_pos_set(ent->entry, inf->change.insert.pos);
elm_entry_entry_insert(ent->entry, inf->change.insert.content);
}
else
{
@ -252,34 +252,35 @@ _undo_redo_do(Evas_Object *ent, Elm_Entry_Change_Info *inf, Eina_Bool undo)
start = (inf->change.del.start < inf->change.del.end) ?
inf->change.del.start : inf->change.del.end;
elm_entry_cursor_pos_set(ent, start);
elm_entry_entry_insert(ent, inf->change.insert.content);
elm_entry_cursor_pos_set(ent, inf->change.del.end);
elm_entry_cursor_pos_set(ent->entry, start);
elm_entry_entry_insert(ent->entry, inf->change.insert.content);
elm_entry_cursor_pos_set(ent->entry, inf->change.del.end);
}
}
/* No matter what, once we did an undo/redo we don't want to merge,
* even if we got backt to the top of the stack. */
undo_stack_can_merge = EINA_FALSE;
ent->undo_stack_can_merge = EINA_FALSE;
}
static void
_undo(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
/* In undo we care about the current item */
Ecrire_Entry *ent = data;
Elm_Entry_Change_Info *inf = NULL;
if (!eina_list_next(undo_stack_ptr))
if (!eina_list_next(ent->undo_stack_ptr))
return;
do
{
inf = eina_list_data_get(undo_stack_ptr);
inf = eina_list_data_get(ent->undo_stack_ptr);
_undo_redo_do(data, inf, EINA_TRUE);
_undo_redo_do(ent, inf, EINA_TRUE);
if (eina_list_next(undo_stack_ptr))
if (eina_list_next(ent->undo_stack_ptr))
{
undo_stack_ptr = eina_list_next(undo_stack_ptr);
ent->undo_stack_ptr = eina_list_next(ent->undo_stack_ptr);
}
else
{
@ -288,24 +289,25 @@ _undo(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
}
while (inf && inf->merge);
_update_undo_redo_items(data);
_update_undo_redo_items(ent);
}
static void
_redo(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
Ecrire_Entry *ent = data;
Elm_Entry_Change_Info *inf = NULL;
if (!eina_list_prev(undo_stack_ptr))
if (!eina_list_prev(ent->undo_stack_ptr))
return;
do
{
if (eina_list_prev(undo_stack_ptr))
if (eina_list_prev(ent->undo_stack_ptr))
{
undo_stack_ptr = eina_list_prev(undo_stack_ptr);
ent->undo_stack_ptr = eina_list_prev(ent->undo_stack_ptr);
/* In redo we care about the NEW item */
inf = eina_list_data_get(undo_stack_ptr);
_undo_redo_do(data, inf, EINA_FALSE);
inf = eina_list_data_get(ent->undo_stack_ptr);
_undo_redo_do(ent, inf, EINA_FALSE);
}
else
{
@ -313,28 +315,29 @@ _redo(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
}
/* Update inf to next for the condition. */
if (eina_list_prev(undo_stack_ptr))
if (eina_list_prev(ent->undo_stack_ptr))
{
inf = eina_list_data_get(eina_list_prev(undo_stack_ptr));
inf = eina_list_data_get(eina_list_prev(ent->undo_stack_ptr));
}
}
while (inf && inf->merge);
_update_undo_redo_items(data);
_update_undo_redo_items(ent);
}
static void
_ent_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info)
{
elm_object_item_disabled_set(save_item, EINA_FALSE);
_update_cur_file(filename, data);
Ecrire_Entry *ent = data;
elm_object_item_disabled_set(ent->save_item, EINA_FALSE);
_update_cur_file(ent->filename, ent);
/* Undo/redo */
_undo_stack_add(event_info);
_undo_stack_add(ent, event_info);
}
static void
_load_to_entry(Evas_Object *ent, const char *file)
_load_to_entry(Ecrire_Entry *ent, const char *file)
{
if (file)
{
@ -345,10 +348,10 @@ _load_to_entry(Evas_Object *ent, const char *file)
else
buf = _load_file(file);
elm_object_text_set(ent, "");
elm_object_text_set(ent->entry, "");
_init_entry(ent);
elm_entry_entry_append(ent, buf);
elm_object_item_disabled_set(save_item, EINA_TRUE);
elm_entry_entry_append(ent->entry, buf);
elm_object_item_disabled_set(ent->save_item, EINA_TRUE);
free(buf);
}
else
@ -356,7 +359,7 @@ _load_to_entry(Evas_Object *ent, const char *file)
_init_entry(ent);
}
_update_cur_file(file, elm_object_top_widget_get(ent));
_update_cur_file(file, ent);
}
static void
@ -364,20 +367,20 @@ _fs_open_done(void *data __UNUSED__, Evas_Object *obj __UNUSED__,
void *event_info)
{
const char *selected = event_info;
_load_to_entry(entry, selected);
_load_to_entry(main_ec_ent, selected);
}
static void
_save_do(const char *file, Evas_Object *ent)
_save_do(const char *file, Ecrire_Entry *ent)
{
if (plain_utf8)
_save_plain_utf8(file, elm_object_text_get(ent));
_save_plain_utf8(file, elm_object_text_get(ent->entry));
else
_save_markup_utf8(file, elm_object_text_get(ent));
_save_markup_utf8(file, elm_object_text_get(ent->entry));
elm_object_item_disabled_set(save_item, EINA_TRUE);
last_saved_stack_ptr = undo_stack_ptr;
_update_cur_file(file, elm_object_top_widget_get(ent));
elm_object_item_disabled_set(ent->save_item, EINA_TRUE);
ent->last_saved_stack_ptr = ent->undo_stack_ptr;
_update_cur_file(file, ent);
}
static void
@ -388,84 +391,95 @@ _fs_save_done(void *data __UNUSED__, Evas_Object *obj __UNUSED__,
if (selected)
{
_save_do(selected, entry);
_save_do(selected, main_ec_ent);
}
}
static void
_open_do(void *data)
{
ui_file_open_save_dialog_open(data, _fs_open_done, EINA_FALSE);
Ecrire_Entry *ent = data;
ui_file_open_save_dialog_open(ent->win, _fs_open_done, EINA_FALSE);
}
static void
_open(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
_alert_if_need_saving(_open_do, data);
Ecrire_Entry *ent = data;
_alert_if_need_saving(_open_do, ent);
}
static void
_save(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
if (filename)
Ecrire_Entry *ent = data;
if (ent->filename)
{
_save_do(filename, entry);
_save_do(ent->filename, ent);
}
else
{
ui_file_open_save_dialog_open(data, _fs_save_done, EINA_TRUE);
ui_file_open_save_dialog_open(ent->win, _fs_save_done, EINA_TRUE);
}
}
static void
_save_as(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
ui_file_open_save_dialog_open(data, _fs_save_done, EINA_TRUE);
Ecrire_Entry *ent = data;
ui_file_open_save_dialog_open(ent->win, _fs_save_done, EINA_TRUE);
}
static void
_new_do(void *data)
{
elm_object_text_set(data, "");
_init_entry(data);
elm_object_item_disabled_set(save_item, EINA_TRUE);
_update_cur_file(NULL, elm_object_top_widget_get(data));
Ecrire_Entry *ent = data;
elm_object_text_set(ent->entry, "");
_init_entry(ent);
elm_object_item_disabled_set(ent->save_item, EINA_TRUE);
_update_cur_file(NULL, ent);
}
static void
_new(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
_alert_if_need_saving(_new_do, data);
Ecrire_Entry *ent = data;
_alert_if_need_saving(_new_do, ent);
}
static void
_cut(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
elm_entry_selection_cut(data);
Ecrire_Entry *ent = data;
elm_entry_selection_cut(ent->entry);
}
static void
_copy(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
elm_entry_selection_copy(data);
Ecrire_Entry *ent = data;
elm_entry_selection_copy(ent->entry);
}
static void
_paste(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
elm_entry_selection_paste(data);
Ecrire_Entry *ent = data;
elm_entry_selection_paste(ent->entry);
}
static void
_find(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
ui_find_dialog_open(elm_object_top_widget_get(data), data);
Ecrire_Entry *ent = data;
ui_find_dialog_open(ent->win, ent);
}
static void
_font_settings(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
ui_font_dialog_open(elm_object_top_widget_get(data), data, _ent_cfg->font.name, _ent_cfg->font.size);
Ecrire_Entry *ent = data;
ui_font_dialog_open(elm_object_top_widget_get(data), ent, _ent_cfg->font.name, _ent_cfg->font.size);
}
@ -478,16 +492,17 @@ _win_del_do(void *data __UNUSED__)
static void
my_win_del(void *data, Evas_Object *obj, void *event_info)
{
Ecrire_Entry *ent = data;
(void) data;
(void) obj;
(void) event_info;
_alert_if_need_saving(_win_del_do, data);
_alert_if_need_saving(_win_del_do, ent);
}
static void
editor_font_set(Evas_Object *ent, const char *font, int font_size)
editor_font_set(Ecrire_Entry *ent, const char *font, int font_size)
{
const Evas_Object *tb = elm_entry_textblock_get(ent);
const Evas_Object *tb = elm_entry_textblock_get(ent->entry);
Eina_Strbuf *sbuf;
eina_stringshare_replace(&_ent_cfg->font.name, font);
@ -521,13 +536,13 @@ editor_font_set(Evas_Object *ent, const char *font, int font_size)
evas_object_textblock_style_user_set((Evas_Object *) tb, NULL);
}
elm_entry_calc_force(ent);
elm_entry_calc_force(ent->entry);
eina_strbuf_free(sbuf);
}
void
editor_font_choose(Evas_Object *ent, const char *font, int size)
editor_font_choose(Ecrire_Entry *ent, const char *font, int size)
{
editor_font_set(ent, font, size);
@ -537,8 +552,9 @@ editor_font_choose(Evas_Object *ent, const char *font, int size)
#ifdef HAVE_ECORE_X
static Eina_Bool
_selection_notify(void *data __UNUSED__, int type __UNUSED__, void *_event)
_selection_notify(void *data, int type __UNUSED__, void *_event)
{
Ecrire_Entry *ent = data;
Ecore_X_Event_Fixes_Selection_Notify *event =
(Ecore_X_Event_Fixes_Selection_Notify *) _event;
@ -547,7 +563,7 @@ _selection_notify(void *data __UNUSED__, int type __UNUSED__, void *_event)
if (event->selection == ECORE_X_SELECTION_CLIPBOARD)
{
elm_object_item_disabled_set(paste_item,
elm_object_item_disabled_set(ent->paste_item,
(event->reason != ECORE_X_OWNER_CHANGE_REASON_NEW_OWNER));
}
@ -558,7 +574,7 @@ _selection_notify(void *data __UNUSED__, int type __UNUSED__, void *_event)
int
main(int argc, char *argv[])
{
Evas_Object *win, *bg, *tbar, *bx, *cur_info;
Evas_Object *bg, *tbar, *bx, *cur_info;
Evas_Coord w = 600, h = 600;
int c;
@ -595,27 +611,33 @@ main(int argc, char *argv[])
ecrire_cfg_init(PACKAGE_NAME);
ecrire_cfg_load();
main_ec_ent = calloc(1, sizeof(*main_ec_ent));
main_ec_ent->unsaved = 1;
main_ec_ent->filename = NULL;
main_ec_ent->last_saved_stack_ptr = NULL;
main_ec_ent->undo_stack_can_merge = EINA_FALSE;
if (optind < argc)
{
filename = eina_stringshare_add(argv[optind]);
main_ec_ent->filename = eina_stringshare_add(argv[optind]);
}
EINA_LOG_DBG("Opening filename: '%s'", filename);
EINA_LOG_DBG("Opening filename: '%s'", main_ec_ent->filename);
win = elm_win_add(NULL, "editor", ELM_WIN_BASIC);
elm_win_autodel_set(win, EINA_FALSE);
main_ec_ent->win = elm_win_add(NULL, "editor", ELM_WIN_BASIC);
elm_win_autodel_set(main_ec_ent->win, EINA_FALSE);
bg = elm_bg_add(win);
elm_win_resize_object_add(win, bg);
bg = elm_bg_add(main_ec_ent->win);
elm_win_resize_object_add(main_ec_ent->win, bg);
evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(bg);
bx = elm_box_add(win);
elm_win_resize_object_add(win, bx);
bx = elm_box_add(main_ec_ent->win);
elm_win_resize_object_add(main_ec_ent->win, bx);
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(bx);
tbar = elm_toolbar_add(win);
tbar = elm_toolbar_add(main_ec_ent->win);
elm_toolbar_homogeneous_set(tbar, 0);
elm_toolbar_shrink_mode_set(tbar, ELM_TOOLBAR_SHRINK_SCROLL);
elm_toolbar_no_select_mode_set(tbar, EINA_TRUE);
@ -626,85 +648,84 @@ main(int argc, char *argv[])
elm_box_pack_end(bx, tbar);
evas_object_show(tbar);
entry = elm_entry_add(win);
elm_entry_scrollable_set(entry, EINA_TRUE);
elm_entry_line_wrap_set(entry, _ent_cfg->wrap_type);
elm_entry_cnp_textonly_set(entry, EINA_TRUE);
evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_box_pack_end(bx, entry);
evas_object_show(entry);
main_ec_ent->entry = elm_entry_add(main_ec_ent->win);
elm_entry_scrollable_set(main_ec_ent->entry, EINA_TRUE);
elm_entry_line_wrap_set(main_ec_ent->entry, _ent_cfg->wrap_type);
elm_entry_cnp_textonly_set(main_ec_ent->entry, EINA_TRUE);
evas_object_size_hint_align_set(main_ec_ent->entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(main_ec_ent->entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_box_pack_end(bx, main_ec_ent->entry);
evas_object_show(main_ec_ent->entry);
cur_info = elm_label_add(win);
_cur_changed(cur_info, entry, NULL);
cur_info = elm_label_add(main_ec_ent->win);
_cur_changed(cur_info, main_ec_ent->entry, NULL);
evas_object_size_hint_align_set(cur_info, 1.0, 0.5);
evas_object_size_hint_weight_set(cur_info, EVAS_HINT_EXPAND, 0.0);
elm_box_pack_end(bx, cur_info);
evas_object_show(cur_info);
evas_object_smart_callback_add(entry, "cursor,changed", _cur_changed,
cur_info);
evas_object_smart_callback_add(entry, "cursor,changed,manual",
_cur_changed_manual,
cur_info);
evas_object_smart_callback_add(entry, "changed,user", _ent_changed, win);
evas_object_smart_callback_add(entry, "undo,request", _undo, entry);
evas_object_smart_callback_add(entry, "redo,request", _redo, entry);
evas_object_smart_callback_add(entry, "selection,start", _sel_start, win);
evas_object_smart_callback_add(entry, "selection,cleared", _sel_clear, win);
evas_object_smart_callback_add(main_ec_ent->entry, "cursor,changed",
_cur_changed, cur_info);
evas_object_smart_callback_add(main_ec_ent->entry, "cursor,changed,manual",
_cur_changed_manual, main_ec_ent);
evas_object_smart_callback_add(main_ec_ent->entry, "changed,user", _ent_changed, main_ec_ent);
evas_object_smart_callback_add(main_ec_ent->entry, "undo,request", _undo, main_ec_ent);
evas_object_smart_callback_add(main_ec_ent->entry, "redo,request", _redo, main_ec_ent);
evas_object_smart_callback_add(main_ec_ent->entry, "selection,start", _sel_start, main_ec_ent);
evas_object_smart_callback_add(main_ec_ent->entry, "selection,cleared", _sel_clear, main_ec_ent);
elm_toolbar_item_append(tbar, "document-new", _("New"), _new, entry);
elm_toolbar_item_append(tbar, "document-open", _("Open"), _open, win);
save_item =
elm_toolbar_item_append(tbar, "document-save", _("Save"), _save, win);
elm_toolbar_item_append(tbar, "document-new", _("New"), _new, main_ec_ent);
elm_toolbar_item_append(tbar, "document-open", _("Open"), _open, main_ec_ent);
main_ec_ent->save_item =
elm_toolbar_item_append(tbar, "document-save", _("Save"), _save, main_ec_ent);
elm_toolbar_item_append(tbar, "document-save-as", _("Save As"), _save_as,
win);
main_ec_ent);
elm_toolbar_item_separator_set(
elm_toolbar_item_append(tbar, "", "", NULL, NULL), EINA_TRUE);
undo_item =
elm_toolbar_item_append(tbar, "edit-undo", _("Undo"), _undo, entry);
redo_item =
elm_toolbar_item_append(tbar, "edit-redo", _("Redo"), _redo, entry);
main_ec_ent->undo_item =
elm_toolbar_item_append(tbar, "edit-undo", _("Undo"), _undo, main_ec_ent);
main_ec_ent->redo_item =
elm_toolbar_item_append(tbar, "edit-redo", _("Redo"), _redo, main_ec_ent);
elm_toolbar_item_separator_set(
elm_toolbar_item_append(tbar, "", "", NULL, NULL), EINA_TRUE);
cut_item = elm_toolbar_item_append(tbar, "edit-cut", _("Cut"), _cut, entry);
copy_item =
elm_toolbar_item_append(tbar, "edit-copy", _("Copy"), _copy, entry);
paste_item =
elm_toolbar_item_append(tbar, "edit-paste", _("Paste"), _paste, entry);
main_ec_ent->cut_item = elm_toolbar_item_append(tbar, "edit-cut", _("Cut"), _cut, main_ec_ent);
main_ec_ent->copy_item =
elm_toolbar_item_append(tbar, "edit-copy", _("Copy"), _copy, main_ec_ent);
main_ec_ent->paste_item =
elm_toolbar_item_append(tbar, "edit-paste", _("Paste"), _paste, main_ec_ent);
elm_toolbar_item_separator_set(
elm_toolbar_item_append(tbar, "", "", NULL, NULL), EINA_TRUE);
elm_toolbar_item_append(tbar, "edit-find-replace", _("Find & Replace"),
_find, entry);
_find, main_ec_ent);
elm_toolbar_item_separator_set(
elm_toolbar_item_append(tbar, "", "", NULL, NULL), EINA_TRUE);
elm_toolbar_item_append(tbar, "preferences-system", _("Settings"),
_font_settings, entry);
_font_settings, main_ec_ent);
#ifdef HAVE_ECORE_X
if (!ecore_x_selection_owner_get(ECORE_X_ATOM_SELECTION_CLIPBOARD))
{
elm_object_item_disabled_set(paste_item, EINA_TRUE);
elm_object_item_disabled_set(main_ec_ent->paste_item, EINA_TRUE);
}
ecore_x_fixes_selection_notification_request(ECORE_X_ATOM_SELECTION_CLIPBOARD);
ecore_event_handler_add(ECORE_X_EVENT_FIXES_SELECTION_NOTIFY,
_selection_notify, NULL);
_selection_notify, main_ec_ent);
#endif
/* We don't have a selection when we start, make the items disabled */
elm_object_item_disabled_set(copy_item, EINA_TRUE);
elm_object_item_disabled_set(cut_item, EINA_TRUE);
elm_object_item_disabled_set(save_item, EINA_TRUE);
elm_object_item_disabled_set(main_ec_ent->copy_item, EINA_TRUE);
elm_object_item_disabled_set(main_ec_ent->cut_item, EINA_TRUE);
elm_object_item_disabled_set(main_ec_ent->save_item, EINA_TRUE);
evas_object_resize(win, w, h);
evas_object_resize(main_ec_ent->win, w, h);
evas_object_smart_callback_add(win, "delete,request", my_win_del, entry);
evas_object_show(win);
evas_object_smart_callback_add(main_ec_ent->win, "delete,request", my_win_del, main_ec_ent);
evas_object_show(main_ec_ent->win);
_load_to_entry(entry, filename);
_load_to_entry(main_ec_ent, main_ec_ent->filename);
elm_object_focus_set(win, EINA_TRUE);
elm_object_focus_set(main_ec_ent->win, EINA_TRUE);
elm_run();

18
src/bin/mess_header.h
View File

@ -3,12 +3,28 @@
#include <Evas.h>
struct _Ecrire_Entry {
Evas_Object *entry;
Evas_Object *win;
const char *filename;
int unsaved;
Elm_Object_Item *copy_item, *cut_item, *save_item, *paste_item, *undo_item, *redo_item;
/* Undo stack */
Eina_List *undo_stack;
Eina_List *undo_stack_ptr;
Eina_List *last_saved_stack_ptr;
Eina_Bool undo_stack_can_merge;
};
typedef struct _Ecrire_Entry Ecrire_Entry;
char *_load_plain(const char *file);
char *_load_file(const char *file);
Eina_Bool _save_markup_utf8(const char *file, const char *text);
Eina_Bool _save_plain_utf8(const char *file, const char *text);
void editor_font_choose(Evas_Object *ent, const char *font, int size);
void editor_font_choose(Ecrire_Entry *ent, const char *font, int size);
#ifdef ENABLE_NLS
# include <libintl.h>

13
src/bin/ui/alerts.c
View File

@ -6,16 +6,21 @@
#include "../mess_header.h"
static void *done_data;
static void (*done_cb)(void *data);
static void
_discard(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
evas_object_del(data);
done_cb(done_data);
}
static void
_save(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
evas_object_del(data);
done_cb(done_data);
}
static void
@ -25,13 +30,15 @@ _cancel(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
}
void
ui_alert_need_saving(void (*done)(void *data), void *data)
ui_alert_need_saving(Evas_Object *entry, void (*done)(void *data), void *data)
{
(void) done;
Evas_Object *inwin, *bx, *hbx, *btn, *lbl;
inwin = elm_win_inwin_add(elm_object_top_widget_get(data));
inwin = elm_win_inwin_add(elm_object_top_widget_get(entry));
evas_object_show(inwin);
done_cb = done;
done_data = data;
bx = elm_box_add(inwin);
elm_win_inwin_content_set(inwin, bx);
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);

10
src/bin/ui/font_dialog.c
View File

@ -51,14 +51,15 @@ static void
_set_clicked(void *data,
Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
Ecrire_Entry *ent = data;
const char *selected = NULL;
Elm_Object_Item *list_it = elm_list_selected_item_get(list);
if (list_it)
selected = elm_object_item_text_get(list_it);
if (elm_check_state_get(dfont_check))
editor_font_choose(data, NULL, 0);
editor_font_choose(ent, NULL, 0);
else
editor_font_choose(data, selected, elm_spinner_value_get(fsize));
editor_font_choose(ent, selected, elm_spinner_value_get(fsize));
}
static void
@ -71,9 +72,10 @@ _check_changed_cb(void *data __UNUSED__, Evas_Object *obj,
Evas_Object *
ui_font_dialog_open(Evas_Object *parent, Evas_Object *entry, const char *pfont,
ui_font_dialog_open(Evas_Object *parent, Ecrire_Entry *ent, const char *pfont,
int size)
{
Evas_Object *entry = ent->entry;
Evas_Object *win, *bg, *bx, *btn, *hbx, *lbl;
if (font_win)
@ -168,7 +170,7 @@ ui_font_dialog_open(Evas_Object *parent, Evas_Object *entry, const char *pfont,
evas_object_size_hint_weight_set(list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(btn);
elm_box_pack_end(hbx, btn);
evas_object_smart_callback_add(btn, "clicked", _set_clicked, entry);
evas_object_smart_callback_add(btn, "clicked", _set_clicked, ent);
/* Forcing it to be the min height. */
evas_object_resize(win, 300, 500);

3
src/bin/ui/search_dialog.c
View File

@ -128,8 +128,9 @@ my_win_del(void *data __UNUSED__, Evas_Object *obj, void *event_info)
}
Evas_Object *
ui_find_dialog_open(Evas_Object *parent, Evas_Object *entry)
ui_find_dialog_open(Evas_Object *parent, Ecrire_Entry *ent)
{
Evas_Object *entry = ent->entry;
Evas_Object *win, *bg, *bx, *lbl, *hbx, *btn;
if (search_win)

8
src/bin/ui/ui.h
View File

@ -1,12 +1,14 @@
#ifndef _UI_H
#define _UI_H
#include "../mess_header.h"
void ui_file_open_save_dialog_open(Evas_Object *parent, Evas_Smart_Cb func, Eina_Bool save);
Evas_Object *ui_find_dialog_open(Evas_Object *parent, Evas_Object *entry);
Evas_Object *ui_find_dialog_open(Evas_Object *parent, Ecrire_Entry *ent);
Evas_Object *ui_font_dialog_open(Evas_Object *parent, Evas_Object *entry, const char *pfont, int size);
Evas_Object *ui_font_dialog_open(Evas_Object *parent, Ecrire_Entry *ent, const char *pfont, int size);
void ui_alert_need_saving(void (*done)(void *), void *data);
void ui_alert_need_saving(Evas_Object *entry, void (*done)(void *data), void *data);
#endif