Shows how to write simple editor using the Ecore_IMF library.
 
#include <Ecore.h>
#include <Ecore_IMF.h>
#include <Ecore_IMF_Evas.h>
#include <Evas.h>
#include <stdio.h>
 
#define WIDTH 480
#define HEIGHT 800
 
typedef struct _Entry Entry;
 
struct _Entry
{
};
 
static void _imf_cursor_info_set(Entry *en);
 
static void
{
   Entry *en = data;
   if (!en) return;
 
   if (en->imf_context)
     {
          return;
 
        
     }
 
   
}
 
static void
{
   Entry *en = data;
   if (!en) return;
 
     {
        _imf_cursor_info_set(en);
        return;
     }
 
   if (en->imf_context)
     {
          return;
     }
 
   if (en->rect)
     {
          {
             
             _imf_cursor_info_set(en);
          }
        else
     }
}
 
static void
{
   Entry *en = data;
   if (!en) return;
 
   if (en->imf_context)
 
   
   _imf_cursor_info_set(en);
}
 
static void
{
   Entry *en = data;
   if (!en) return;
 
   if (en->imf_context)
     {
        
     }
}
 
static void
{
   Entry *en;
   if (!obj) return;
 
   if (en)
     _entry_focus_in_cb(en, NULL, NULL, NULL);
}
 
static void
{
   Entry *en;
   if (!obj) return;
 
   if (en)
     _entry_focus_out_cb(en, NULL, NULL, NULL);
}
 
static void
_imf_cursor_info_set(Entry *en)
{
   int cursor_pos; 
   Evas_BiDi_Direction dir;
 
   if (!en) return;
 
   
   if (en->txt_obj)
 
   if (en->cursor && en->imf_context)
     {
 
        
 
     }
}
 
static void
_preedit_del(Entry *en)
{
   if (!en || !en->have_preedit) return;
   if (!en->preedit_start || !en->preedit_end) return;
 
   
}
 
static void
_preedit_clear(Entry *en)
{
   if (en->preedit_start)
     {
        en->preedit_start = NULL;
     }
 
   if (en->preedit_end)
     {
        en->preedit_end = NULL;
     }
 
}
 
{
   
   Entry *en = data;
   const char *str;
 
 
 
   if (text)
     *text = str ? strdup(str) : strdup("");
 
   
   if (cursor_pos && en->cursor)
 
}
 
static void
{
   
   Entry *en = data;
   int cursor_pos;
 
   if ((!en) || (!ev) || (!en->cursor)) return;
 
   
 
   
 
   
 
   
 
}
 
static void
{
   Entry *en = data;
   char *commit_str = (char *)event_info;
   if (!en) return;
 
   
   _preedit_del(en);
   _preedit_clear(en);
 
   printf("commit string : %s\n", commit_str);
 
   
   if (en->cursor && commit_str)
 
   
   _imf_cursor_info_set(en);
 
   return;
}
 
static void
{
   
   Entry *en = data;
   char *preedit_string;
   int cursor_pos;
   int preedit_start_pos, preedit_end_pos;
   int i;
 
   if (!en || !en->cursor) return;
 
   
   printf("preedit string : %s\n", preedit_string);
 
   if (!strcmp(preedit_string, ""))
 
   
   _preedit_del(en);
 
 
   
   if (strlen(preedit_string) > 0)
     {
        if (attrs)
          {
               {
                    {
                       
                    }
                    {
                       
                    }
               }
 
             
          }
     }
 
   if (!preedit_end_state)
     {
        
        if (!en->preedit_start)
 
        
        if (!en->preedit_end)
 
 
        for (i = 0; i < (preedit_end_pos - preedit_start_pos); i++)
          {
          }
 
 
        
     }
 
   
   _imf_cursor_info_set(en);
 
     free(attr);
 
   free(preedit_string);
}
 
static void
{
   Entry *en = data;
   if ((!en) || (!ev->
key) || (!en->cursor)) 
return;
 
 
   if (en->imf_context)
     {
          return;
     }
 
   (void)alt;
   (void)shift;
 
   if (!strcmp(ev->
key, 
"BackSpace"))
 
     {
          {
             
             _imf_cursor_info_set(en);
          }
         return;
     }
   else if (!strcmp(ev->
key, 
"Delete") ||
 
            (!strcmp(ev->
key, 
"KP_Delete") && !ev->
string))
     {
        
     }
   else if ((control) && (!strcmp(ev->
key, 
"v")))
 
     {
        
        
     }
   else if ((control) && (!strcmp(ev->
key, 
"a")))
 
     {
        
        
     }
   else if ((control) && (!strcmp(ev->
key, 
"A")))
 
     {
        
        
     }
   else if ((control) && ((!strcmp(ev->
key, 
"c") || (!strcmp(ev->
key, 
"Insert")))))
 
     {
        
        
     }
   else if ((control) && ((!strcmp(ev->
key, 
"x") || (!strcmp(ev->
key, 
"m")))))
 
     {
        
        
     }
   else if ((control) && (!strcmp(ev->
key, 
"z")))
 
     {
        
        
     }
   else if ((control) && (!strcmp(ev->
key, 
"y")))
 
     {
        
        
     }
   else if ((!strcmp(ev->
key, 
"Return")) || (!strcmp(ev->
key, 
"KP_Enter")))
 
     {
        
     }
   else
     {
          {
             printf(
"key down string : %s\n", ev->
string);
          }
     }
 
   
   _imf_cursor_info_set(en);
}
 
static void
{
   Entry *en = data;
 
   if (!en) return;
 
   if (en->imf_context)
     {
 
          return;
     }
}
 
static void
{
   if (!en) return;
 
   en->preedit_start = NULL;
   en->preedit_end = NULL;
 
   
 
   
 
   
   static const char *style_buf =
      "DEFAULT='font=Sans font_size=30 color=#000 text_class=entry'"
      "newline='br'"
      "b='+ font=Sans:style=bold'";
 
   
 
   
   if (!default_id)
     {
        fprintf(stderr, "Can't create ecore_imf_context\n");
        return;
     }
 
 
   
 
   
 
   
 
   
 
   
 
   
 
   
}
 
static void
delete_input_field(Entry *en)
{
   if (!en) return;
 
   if (en->rect)
     {
        en->rect = NULL;
     }
 
   if (en->cursor)
     {
        en->cursor = NULL;
     }
 
   if (en->preedit_start)
     {
        en->preedit_start = NULL;
     }
 
   if (en->preedit_end)
     {
        en->preedit_end = NULL;
     }
 
   if (en->txt_obj)
     {
        en->txt_obj = NULL;
     }
 
   if (en->txt_style)
     {
        en->txt_style = NULL;
     }
 
   if (en->imf_context)
     {
        en->imf_context = NULL;
     }
}
 
int
main(void)
{
   Ecore_Evas *ee;
   Entry en1, en2;
 
     {
        fprintf(stderr, "failed to call ecore_evas_init()\n");
        return EXIT_FAILURE;
     }
 
 
   
 
   if (!ee)
     {
        fprintf(stderr, "failed to call ecore_evas_new\n");
        return EXIT_FAILURE;
     }
 
 
   
   if (!evas)
     {
        fprintf(stderr, "failed to call ecore_evas_get\n");
        return EXIT_FAILURE;
     }
 
   
 
   
 
   memset(&en1, 0, sizeof(en1));
   memset(&en2, 0, sizeof(en2));
 
   
   create_input_field(evas, &en1, 40, 60, 400, 80);
 
   
   create_input_field(evas, &en2, 40, 180, 400, 80);
 
   
 
 
   delete_input_field(&en1); 
   delete_input_field(&en2); 
 
 
 
 
   return 0;
}
 
int Evas_Coord
Type used for coordinates (in pixels, int).
Definition: Evas_Common.h:116
@ EVAS_EVENT_FLAG_ON_HOLD
This event is being delivered but should be put "on hold" until the on hold flag is unset.
Definition: Evas_Common.h:368
@ EVAS_CALLBACK_KEY_DOWN
Key Press Event.
Definition: Evas_Common.h:430
@ EVAS_CALLBACK_CANVAS_FOCUS_OUT
Canvas lost focus as a whole.
Definition: Evas_Common.h:444
@ EVAS_CALLBACK_FOCUS_IN
Focus In Event.
Definition: Evas_Common.h:432
@ EVAS_CALLBACK_MOUSE_UP
Mouse Button Up Event.
Definition: Evas_Common.h:423
@ EVAS_CALLBACK_MOUSE_DOWN
Mouse Button Down Event.
Definition: Evas_Common.h:422
@ EVAS_CALLBACK_FOCUS_OUT
Focus Out Event.
Definition: Evas_Common.h:433
@ EVAS_CALLBACK_CANVAS_FOCUS_IN
Canvas got focus as a whole.
Definition: Evas_Common.h:443
@ EVAS_CALLBACK_KEY_UP
Key Release Event.
Definition: Evas_Common.h:431
EAPI int ecore_evas_init(void)
Inits the Ecore_Evas system.
Definition: ecore_evas.c:606
EAPI void ecore_evas_show(Ecore_Evas *ee)
Shows an Ecore_Evas' window.
Definition: ecore_evas.c:1506
EAPI Evas * ecore_evas_get(const Ecore_Evas *ee)
Gets an Ecore_Evas's Evas.
Definition: ecore_evas.c:1326
EAPI int ecore_evas_shutdown(void)
Shuts down the Ecore_Evas system.
Definition: ecore_evas.c:674
EAPI Ecore_Evas * ecore_evas_new(const char *engine_name, int x, int y, int w, int h, const char *extra_options)
Creates a new Ecore_Evas based on engine name and common parameters.
Definition: ecore_evas.c:1065
EAPI void ecore_evas_free(Ecore_Evas *ee)
Frees an Ecore_Evas.
Definition: ecore_evas.c:1109
EAPI const char * ecore_imf_context_default_id_get(void)
Gets the id of the default Input Method Context.
Definition: ecore_imf_context.c:56
EAPI void ecore_imf_context_focus_in(Ecore_IMF_Context *ctx)
Notifies the Input Method Context that the widget to which its correspond has gained focus.
Definition: ecore_imf_context.c:352
EAPI void ecore_imf_context_preedit_string_with_attributes_get(Ecore_IMF_Context *ctx, char **str, Eina_List **attrs, int *cursor_pos)
Retrieves the current preedit string, attributes and cursor position for the Input Method Context.
Definition: ecore_imf_context.c:333
EAPI void ecore_imf_context_event_callback_add(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, Ecore_IMF_Event_Cb func, const void *data)
Adds (registers) a callback function to a given context event.
Definition: ecore_imf_context.c:767
EAPI void ecore_imf_context_cursor_location_set(Ecore_IMF_Context *ctx, int x, int y, int w, int h)
Notifies the Input Method Context that a change in the cursor location has been made.
Definition: ecore_imf_context.c:404
EAPI void ecore_imf_context_reset(Ecore_IMF_Context *ctx)
Notifies the Input Method Context that a change such as a change in cursor position has been made.
Definition: ecore_imf_context.c:378
EAPI void ecore_imf_context_client_canvas_set(Ecore_IMF_Context *ctx, void *canvas)
Sets the client canvas for the Input Method Context; this is the canvas in which the input appears.
Definition: ecore_imf_context.c:261
EAPI void ecore_imf_context_del(Ecore_IMF_Context *ctx)
Deletes the given Input Method Context and free its memory.
Definition: ecore_imf_context.c:199
Ecore_IMF_BiDi_Direction
Enumeration for defining the types of Ecore_IMF bidirectionality.
Definition: Ecore_IMF.h:471
struct _Ecore_IMF_Context Ecore_IMF_Context
An Input Method Context.
Definition: Ecore_IMF.h:198
EAPI Eina_Bool ecore_imf_context_filter_event(Ecore_IMF_Context *ctx, Ecore_IMF_Event_Type type, Ecore_IMF_Event *event)
Allows an Ecore Input Context to internally handle an event.
Definition: ecore_imf_context.c:544
EAPI Ecore_IMF_Context * ecore_imf_context_add(const char *id)
Creates a new Input Method Context defined by the given id.
Definition: ecore_imf_context.c:146
EAPI void ecore_imf_context_bidi_direction_set(Ecore_IMF_Context *ctx, Ecore_IMF_BiDi_Direction direction)
Sets the bidirectionality at the current cursor position.
Definition: ecore_imf_context.c:1384
EAPI void ecore_imf_context_retrieve_surrounding_callback_set(Ecore_IMF_Context *ctx, Eina_Bool(*func)(void *data, Ecore_IMF_Context *ctx, char **text, int *cursor_pos), const void *data)
Sets the callback to be used on surrounding_get request.
Definition: ecore_imf_context.c:491
EAPI void ecore_imf_context_cursor_position_set(Ecore_IMF_Context *ctx, int cursor_pos)
Notifies the Input Method Context that a change in the cursor position has been made.
Definition: ecore_imf_context.c:391
EAPI void ecore_imf_context_focus_out(Ecore_IMF_Context *ctx)
Notifies the Input Method Context that the widget to which its correspond has lost focus.
Definition: ecore_imf_context.c:365
@ ECORE_IMF_CALLBACK_DELETE_SURROUNDING
"DELETE_SURROUNDING" is called when the input method needs to delete all or part of the context surro...
Definition: Ecore_IMF.h:233
@ ECORE_IMF_CALLBACK_COMMIT
"COMMIT" is called when a complete input sequence has been entered by the user
Definition: Ecore_IMF.h:232
@ ECORE_IMF_CALLBACK_PREEDIT_CHANGED
"PREEDIT_CHANGED" is called whenever the preedit sequence currently being entered has changed.
Definition: Ecore_IMF.h:231
@ ECORE_IMF_EVENT_KEY_UP
Key Up event.
Definition: Ecore_IMF.h:257
@ ECORE_IMF_EVENT_MOUSE_UP
Mouse Up event.
Definition: Ecore_IMF.h:251
@ ECORE_IMF_EVENT_MOUSE_DOWN
Mouse Down event.
Definition: Ecore_IMF.h:250
@ ECORE_IMF_EVENT_KEY_DOWN
Key Down event.
Definition: Ecore_IMF.h:256
@ ECORE_IMF_PREEDIT_TYPE_SUB1
Substring style 1.
Definition: Ecore_IMF.h:322
@ ECORE_IMF_PREEDIT_TYPE_SUB2
Substring style 2.
Definition: Ecore_IMF.h:323
@ ECORE_IMF_PREEDIT_TYPE_SUB3
Substring style 3.
Definition: Ecore_IMF.h:324
EAPI void ecore_imf_evas_event_key_up_wrap(Evas_Event_Key_Up *evas_event, Ecore_IMF_Event_Key_Up *imf_event)
Converts a "key_up" event from Evas to the corresponding event of Ecore_IMF.
Definition: ecore_imf_evas.c:207
EAPI void ecore_imf_evas_event_key_down_wrap(Evas_Event_Key_Down *evas_event, Ecore_IMF_Event_Key_Down *imf_event)
Converts a "key_down" event from Evas to the corresponding event of Ecore_IMF.
Definition: ecore_imf_evas.c:176
EAPI void ecore_imf_evas_event_mouse_down_wrap(Evas_Event_Mouse_Down *evas_event, Ecore_IMF_Event_Mouse_Down *imf_event)
Converts a "mouse_down" event from Evas to the corresponding event of Ecore_IMF.
Definition: ecore_imf_evas.c:121
EAPI void ecore_imf_evas_event_mouse_up_wrap(Evas_Event_Mouse_Up *evas_event, Ecore_IMF_Event_Mouse_Up *imf_event)
Converts a "mouse_up" event from Evas to the corresponding event of Ecore_IMF.
Definition: ecore_imf_evas.c:139
EAPI int ecore_imf_shutdown(void)
Shuts down the Ecore_IMF library.
Definition: ecore_imf.c:47
EAPI int ecore_imf_init(void)
Initialises the Ecore_IMF library.
Definition: ecore_imf.c:22
void ecore_main_loop_begin(void)
Runs the application main loop.
Definition: ecore_main.c:1298
#define EINA_LIST_FOREACH(list, l, _data)
Definition for the macro to iterate over a list.
Definition: eina_list.h:1415
#define EINA_LIST_FREE(list, data)
Definition for the macro to remove each list node while having access to each node's data.
Definition: eina_list.h:1629
#define EINA_TRUE
boolean value TRUE (numerical value 1)
Definition: eina_types.h:539
#define EINA_FALSE
boolean value FALSE (numerical value 0)
Definition: eina_types.h:533
unsigned char Eina_Bool
Type to mimic a boolean.
Definition: eina_types.h:527
#define EINA_UNUSED
Used to indicate that a function parameter is purposely unused.
Definition: eina_types.h:339
static void _mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
For all mouse* / multi_* functions wethen send this event to _event_process function.
Definition: elm_gesture_layer.c:865
void * evas_event_callback_del_full(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data)
Delete (unregister) a callback function registered to a given canvas event.
Definition: evas_callbacks.c:678
void evas_event_callback_add(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data)
Add (register) a callback function to a given canvas event.
Definition: evas_callbacks.c:573
Eo Evas
An opaque handle to an Evas canvas.
Definition: Evas_Common.h:163
Efl_Canvas_Object * evas_focus_get(const Evas_Canvas *obj)
Retrieve the object focused by the default seat.
Definition: evas_canvas_eo.legacy.c:51
Eina_Bool evas_key_modifier_is_set(const Evas_Modifier *m, const char *keyname)
Checks the state of a given modifier of the default seat, at the time of the call.
Definition: evas_key.c:76
void evas_object_geometry_get(const Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
Retrieves the position and (rectangular) size of the given Evas object.
Definition: evas_object_main.c:1335
void evas_object_del(Evas_Object *obj)
Marks the given Evas object for deletion (when Evas will free its memory).
Definition: evas_object_main.c:928
void evas_object_show(Evas_Object *eo_obj)
Makes the given Evas object visible.
Definition: evas_object_main.c:1814
void evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a)
Sets the general/main color of the given Evas object to the given one.
Definition: evas_object_main.c:2024
void evas_object_event_callback_add(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data)
Add (register) a callback function to a given Evas object event.
Definition: evas_callbacks.c:478
void evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
Move the given Evas object to the given location inside its canvas' viewport.
Definition: evas_object_main.c:1171
void evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
Changes the size of the given Evas object.
Definition: evas_object_main.c:1236
void evas_object_focus_set(Efl_Canvas_Object *obj, Eina_Bool focus)
Indicates that this object is the keyboard event receiver on its canvas.
Definition: efl_canvas_object_eo.legacy.c:39
Eina_Bool evas_object_focus_get(const Efl_Canvas_Object *obj)
Indicates that this object is the keyboard event receiver on its canvas.
Definition: efl_canvas_object_eo.legacy.c:45
void evas_object_pass_events_set(Efl_Canvas_Object *obj, Eina_Bool pass)
Set whether an Evas object is to pass (ignore) events.
Definition: efl_canvas_object_eo.legacy.c:76
Efl_Canvas_Object Evas_Object
An Evas Object handle.
Definition: Evas_Common.h:185
Evas_Object * evas_object_rectangle_add(Evas *e)
Adds a rectangle to the given evas.
Definition: evas_object_rectangle.c:78
Eina_Bool evas_textblock_cursor_char_prev(Efl_Text_Cursor_Handle *cur)
Advances the cursor one char backwards.
Definition: evas_object_textblock.c:10612
struct _Efl_Canvas_Textblock_Style Evas_Textblock_Style
A textblock style object.
Definition: evas_textblock_legacy.h:140
void evas_object_textblock_style_set(Eo *eo_obj, const Evas_Textblock_Style *ts)
Sets object's style to given style.
Definition: evas_object_textblock.c:8299
int evas_textblock_cursor_pos_get(const Efl_Text_Cursor_Handle *cur)
Return the current cursor pos.
Definition: evas_object_textblock.c:11219
Efl_Text_Cursor_Handle * evas_object_textblock_cursor_new(const Evas_Object *eo_obj)
Create a new cursor, associate it to the obj and init it to point to the start of the textblock.
Definition: evas_object_textblock.c:9790
Evas_Textblock_Style * evas_textblock_style_new(void)
Creates a new textblock style.
Definition: evas_object_textblock.c:7966
Evas_Object * evas_object_textblock_add(Evas *e)
Adds a textblock to the given evas.
Definition: evas_object_textblock.c:7902
void evas_textblock_cursor_free(Evas_Textblock_Cursor *cur)
Free the cursor and unassociate it from the object.
Definition: evas_object_textblock.c:9810
void evas_textblock_cursor_copy(const Evas_Textblock_Cursor *cur_src, Efl_Text_Cursor_Handle *cur_dest)
Make cur_dest point to the same place as cur.
Definition: evas_object_textblock.c:11406
void evas_textblock_cursor_char_delete(Efl_Text_Cursor_Handle *cur)
Deletes a single character from position pointed by given cursor.
Definition: evas_object_textblock.c:12163
const char * evas_object_textblock_text_markup_get(Eo *eo_obj)
Gets the current markup text of the textblock object.
Definition: evas_object_textblock.c:9108
void evas_textblock_cursor_pos_set(Efl_Text_Cursor_Handle *cur, int _pos)
Set the cursor pos.
Definition: evas_object_textblock.c:11239
void evas_object_textblock_text_markup_prepend(Efl_Text_Cursor_Handle *cur, const char *text)
Prepends markup to the cursor cur.
Definition: evas_object_textblock.c:8951
int evas_textblock_cursor_compare(const Efl_Text_Cursor_Handle *cur1, const Efl_Text_Cursor_Handle *cur2)
Compare two cursors.
Definition: evas_object_textblock.c:11370
int evas_textblock_cursor_geometry_get(const Efl_Text_Cursor_Handle *cur, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch, Evas_BiDi_Direction *dir, Evas_Textblock_Cursor_Type ctype)
Returns the geometry of the cursor.
Definition: evas_object_textblock.c:12976
void evas_textblock_cursor_range_delete(Efl_Text_Cursor_Handle *cur1, Efl_Text_Cursor_Handle *cur2)
Delete the range between cur1 and cur2.
Definition: evas_object_textblock.c:12242
void evas_textblock_style_set(Evas_Textblock_Style *ts, const char *text)
Sets the style ts to the style passed as text by text.
Definition: evas_object_textblock.c:8043
void evas_textblock_style_free(Evas_Textblock_Style *ts)
Destroys a textblock style.
Definition: evas_object_textblock.c:7976
@ EVAS_TEXTBLOCK_CURSOR_BEFORE
cursor type is before
Definition: evas_textblock_legacy.h:190
The structure type used with the Delete_Surrounding Input Method event.
Definition: Ecore_IMF.h:556
The structure type used with the Key_Down event.
Definition: Ecore_IMF.h:704
The structure type used with the Key_Up event.
Definition: Ecore_IMF.h:723
The structure type used with the Mouse_Down event.
Definition: Ecore_IMF.h:591
The structure type used with the Mouse_Up event.
Definition: Ecore_IMF.h:610
Structure that contains preedit attribute information.
Definition: Ecore_IMF.h:757
Ecore_IMF_Preedit_Type preedit_type
preedit style type
Definition: Ecore_IMF.h:758
Definition: efl_canvas_textblock_internal.h:160
Type for a generic double linked list.
Definition: eina_list.h:318
Key press event.
Definition: Evas_Legacy.h:314
Evas_Modifier * modifiers
modifier keys pressed during the event
Definition: Evas_Legacy.h:317
const char * string
A UTF8 string if this keystroke has produced a visible string to be ADDED.
Definition: Evas_Legacy.h:321
const char * key
The logical key : (eg shift+1 == exclamation)
Definition: Evas_Legacy.h:320
Key release event.
Definition: Evas_Legacy.h:331
Mouse button press event.
Definition: Evas_Legacy.h:160
Mouse button release event.
Definition: Evas_Legacy.h:178
A union of IMF events.
Definition: Ecore_IMF.h:741