src/lib/ecore_imf/Ecore_IMF.h

   1 #ifndef _ECORE_IMF_H
   2 #define _ECORE_IMF_H
   3
   4 #include <Eina.h>
   5 #include <Ecore_IMF_Input_Panel_Key.h>
   6
   7 #ifdef EAPI
   8 # undef EAPI
   9 #endif
  10
  11 #ifdef _WIN32
  12 # ifdef EFL_ECORE_IMF_BUILD
  13 #  ifdef DLL_EXPORT
  14 #   define EAPI __declspec(dllexport)
  15 #  else
  16 #   define EAPI
  17 #  endif /* ! DLL_EXPORT */
  18 # else
  19 #  define EAPI __declspec(dllimport)
  20 # endif /* ! EFL_ECORE_IMF_BUILD */
  21 #else
  22 # ifdef __GNUC__
  23 #  if __GNUC__ >= 4
  24 #   define EAPI __attribute__ ((visibility("default")))
  25 #  else
  26 #   define EAPI
  27 #  endif
  28 # else
  29 #  define EAPI
  30 # endif
  31 #endif /* ! _WIN32 */
  32
  33 /* Faked 'bool'.  */
  34 #ifndef __cplusplus
  35 # ifndef bool
  36 #  define bool int
  37 #  ifndef FALSE
  38 #   define FALSE 0
  39 #  endif
  40 #  ifndef TRUE
  41 #   define TRUE 1
  42 #  endif
  43 # endif
  44 #endif
  45
  46 /**
  47  * @file Ecore_IMF.h
  48  * @brief The file that provides the ISF IMCONTROL Structures and APIs
  49  * @version   1.0
  50  * @ingroup   Ecore_IMF_Context_IMControl_Group
  51  */
  52
  53 #ifdef __cplusplus
  54 extern "C" {
  55 #endif
  56
  57    /* ecore_imf_context_input_panel_event_callback_add() flag */
  58    typedef enum
  59      {
  60         ECORE_IMF_INPUT_PANEL_STATE_EVENT,              /**< Input Panel STATE Event */
  61         ECORE_IMF_INPUT_PANEL_MODE_EVENT,               /**< Input Panel MODE Event */
  62         ECORE_IMF_INPUT_PANEL_LANGUAGE_EVENT,           /**< Input Panel LANGUAGE Event */
  63         ECORE_IMF_INPUT_PANEL_SHIFT_MODE_EVENT,         /**< Input Panel SHIFT MODE */
  64         ECORE_IMF_INPUT_PANEL_PREEDIT_MODE_EVENT,       /**< Input Panel PREEDIT MODE */
  65         ECORE_IMF_INPUT_PANEL_COMPLETION_MODE_EVENT,    /**< Input Panel COMPLETION MODE */
  66         ECORE_IMF_INPUT_PANEL_CUSTOM_INPUT_MODE_EVENT,  /**< Input Panel CUSTOM INPUT MODE */
  67
  68         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_01,       /**< Input Panel PRIVATE CONTEXT */
  69         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_02,       /**< Input Panel PRIVATE CONTEXT */
  70         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_03,       /**< Input Panel PRIVATE CONTEXT */
  71         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_04,       /**< Input Panel PRIVATE CONTEXT */
  72         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_05,       /**< Input Panel PRIVATE CONTEXT */
  73         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_06,       /**< Input Panel PRIVATE CONTEXT */
  74         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_07,       /**< Input Panel PRIVATE CONTEXT */
  75         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_08,       /**< Input Panel PRIVATE CONTEXT */
  76         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_09,       /**< Input Panel PRIVATE CONTEXT */
  77         ECORE_IMF_INPUT_PANEL_PRIVATE_CONTEXT_10,       /**< Input Panel PRIVATE CONTEXT */
  78         ECORE_IMF_INPUT_PANEL_EVENT_INVALID
  79      } Ecore_IMF_Input_Panel_Event;
  80
  81    typedef enum
  82      {
  83         ECORE_IMF_INPUT_PANEL_STATE_SHOW,         /**< Show Input panel */
  84         ECORE_IMF_INPUT_PANEL_STATE_HIDE,         /**< Hide Input panel */
  85         ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW,    /**< Input panel will be shown */
  86         ECORE_IMF_INPUT_PANEL_STATE_WILL_HIDE,    /**< Input panel will be hidden */
  87         ECORE_IMF_INPUT_PANEL_STATE_INVALID
  88      } Ecore_IMF_Input_Panel_State;
  89
  90    typedef enum
  91      {
  92         ECORE_IMF_INPUT_PANEL_LAYOUT_NORMAL,          /**< Default 4x4 layout */
  93         ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBER,          /**< Number layout */
  94         ECORE_IMF_INPUT_PANEL_LAYOUT_EMAIL,           /**< Email layout */
  95         ECORE_IMF_INPUT_PANEL_LAYOUT_URL,             /**< URL layout */
  96         ECORE_IMF_INPUT_PANEL_LAYOUT_PHONENUMBER,     /**< Phone Number layout */
  97         ECORE_IMF_INPUT_PANEL_LAYOUT_IP,              /**< IP layout */
  98         ECORE_IMF_INPUT_PANEL_LAYOUT_MONTH,           /**< Month layout */
  99         ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBERONLY,      /**< Number Only layout */
 100         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_1 = 100,  /* Reserved for future use */
 101         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_2,
 102         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_3,
 103         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_4,
 104         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_5,
 105         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_6,
 106         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_7,
 107         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_8,
 108         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_9,
 109         ECORE_IMF_INPUT_PANEL_LAYOUT_CUSTOM_10,
 110         ECORE_IMF_INPUT_PANEL_LAYOUT_INVALID
 111      } Ecore_IMF_Input_Panel_Layout;
 112
 113    typedef enum
 114      {
 115         ECORE_IMF_INPUT_PANEL_LANG_AUTOMATIC,  /**< Automatic */
 116         ECORE_IMF_INPUT_PANEL_LANG_ALPHABET    /**< Alphabet */
 117      } Ecore_IMF_Input_Panel_Lang;
 118
 119    typedef enum
 120      {
 121         ECORE_IMF_KEYBOARD_LANG_NATIVE,    /**< Native */
 122         ECORE_IMF_KEYBOARD_LANG_ALPHABET   /**< Alphabet */
 123      } Ecore_IMF_Keyboard_Lang;
 124
 125    typedef enum
 126      {
 127         ECORE_IMF_AUTOCORRECTION_DEFAULT,
 128         ECORE_IMF_AUTOCORRECTION_NO,
 129         ECORE_IMF_AUTOCORRECTION_YES,
 130         ECORE_IMF_AUTOCORRECTION_INVALID
 131      } Ecore_IMF_Autocorrection;
 132
 133    typedef enum
 134      {
 135         ECORE_IMF_INPUT_PANEL_CAPS_MODE_OFF,    /**< Off */
 136         ECORE_IMF_INPUT_PANEL_CAPS_MODE_ON,     /**< On */
 137         ECORE_IMF_INPUT_PANEL_CAPS_MODE_LOCK,   /**< Lock */
 138      } Ecore_IMF_Input_Panel_Caps_Mode;
 139
 140    typedef enum
 141      {
 142         ECORE_IMF_INPUT_PANEL_ORIENT_NONE,
 143         ECORE_IMF_INPUT_PANEL_ORIENT_90_CW, /* Clockwise */
 144         ECORE_IMF_INPUT_PANEL_ORIENT_180,
 145         ECORE_IMF_INPUT_PANEL_ORIENT_90_CCW /* CounterClockwise */
 146      } Ecore_IMF_Input_Panel_Orient;
 147
 148    typedef struct
 149      {
 150         int layout_idx;
 151         int key_idx;
 152         Eina_Bool disabled;
 153      } Disable_Key_Item;
 154
 155    typedef struct
 156      {
 157         int layout_idx;
 158         int key_idx;
 159         int type;
 160         char data[128]; // label or image path
 161         int key_value;
 162         char key_string[32];
 163      } Private_Key_Item;
 164
 165    /* Events sent by the Input Method */
 166    typedef struct _Ecore_IMF_Event_Preedit_Start      Ecore_IMF_Event_Preedit_Start;
 167    typedef struct _Ecore_IMF_Event_Preedit_End        Ecore_IMF_Event_Preedit_End;
 168    typedef struct _Ecore_IMF_Event_Preedit_Changed    Ecore_IMF_Event_Preedit_Changed;
 169    typedef struct _Ecore_IMF_Event_Commit             Ecore_IMF_Event_Commit;
 170    typedef struct _Ecore_IMF_Event_Delete_Surrounding Ecore_IMF_Event_Delete_Surrounding;
 171
 172    /* Events to filter */
 173    typedef struct _Ecore_IMF_Event_Mouse_Down         Ecore_IMF_Event_Mouse_Down;
 174    typedef struct _Ecore_IMF_Event_Mouse_Up           Ecore_IMF_Event_Mouse_Up;
 175    typedef struct _Ecore_IMF_Event_Mouse_In           Ecore_IMF_Event_Mouse_In;
 176    typedef struct _Ecore_IMF_Event_Mouse_Out          Ecore_IMF_Event_Mouse_Out;
 177    typedef struct _Ecore_IMF_Event_Mouse_Move         Ecore_IMF_Event_Mouse_Move;
 178    typedef struct _Ecore_IMF_Event_Mouse_Wheel        Ecore_IMF_Event_Mouse_Wheel;
 179    typedef struct _Ecore_IMF_Event_Key_Down           Ecore_IMF_Event_Key_Down;
 180    typedef struct _Ecore_IMF_Event_Key_Up             Ecore_IMF_Event_Key_Up;
 181    typedef union  _Ecore_IMF_Event                    Ecore_IMF_Event;
 182
 183    typedef struct _Ecore_IMF_Context                  Ecore_IMF_Context;                  /**< An Input Method Context */
 184    typedef struct _Ecore_IMF_Context_Class            Ecore_IMF_Context_Class;            /**< An Input Method Context class */
 185    typedef struct _Ecore_IMF_Context_Info             Ecore_IMF_Context_Info;             /**< An Input Method Context info */
 186
 187    EAPI extern int ECORE_IMF_EVENT_PREEDIT_START;
 188    EAPI extern int ECORE_IMF_EVENT_PREEDIT_END;
 189    EAPI extern int ECORE_IMF_EVENT_PREEDIT_CHANGED;
 190    EAPI extern int ECORE_IMF_EVENT_COMMIT;
 191    EAPI extern int ECORE_IMF_EVENT_DELETE_SURROUNDING;
 192
 193    typedef enum
 194      {
 195         ECORE_IMF_EVENT_MOUSE_DOWN,
 196         ECORE_IMF_EVENT_MOUSE_UP,
 197         ECORE_IMF_EVENT_MOUSE_IN,
 198         ECORE_IMF_EVENT_MOUSE_OUT,
 199         ECORE_IMF_EVENT_MOUSE_MOVE,
 200         ECORE_IMF_EVENT_MOUSE_WHEEL,
 201         ECORE_IMF_EVENT_KEY_DOWN,
 202         ECORE_IMF_EVENT_KEY_UP
 203      } Ecore_IMF_Event_Type;
 204
 205    typedef enum
 206      {
 207         ECORE_IMF_KEYBOARD_MODIFIER_NONE  = 0,      /**< No active modifiers */
 208         ECORE_IMF_KEYBOARD_MODIFIER_CTRL  = 1 << 0, /**< "Control" is pressed */
 209         ECORE_IMF_KEYBOARD_MODIFIER_ALT   = 1 << 1, /**< "Alt" is pressed */
 210         ECORE_IMF_KEYBOARD_MODIFIER_SHIFT = 1 << 2, /**< "Shift" is pressed */
 211         ECORE_IMF_KEYBOARD_MODIFIER_WIN   = 1 << 3  /**< "Win" (between "Ctrl" and "Alt") is pressed */
 212      } Ecore_IMF_Keyboard_Modifiers;
 213
 214    typedef enum
 215      {
 216         ECORE_IMF_KEYBOARD_LOCK_NONE      = 0,      /**< No locks are active */
 217         ECORE_IMF_KEYBOARD_LOCK_NUM       = 1 << 0, /**< "Num" lock is active */
 218         ECORE_IMF_KEYBOARD_LOCK_CAPS      = 1 << 1, /**< "Caps" lock is active */
 219         ECORE_IMF_KEYBOARD_LOCK_SCROLL    = 1 << 2  /**< "Scroll" lock is active */
 220      } Ecore_IMF_Keyboard_Locks;
 221
 222    typedef enum
 223      {
 224         ECORE_IMF_MOUSE_NONE              = 0,      /**< A single click */
 225         ECORE_IMF_MOUSE_DOUBLE_CLICK      = 1 << 0, /**< A double click */
 226         ECORE_IMF_MOUSE_TRIPLE_CLICK      = 1 << 1  /**< A triple click */
 227      } Ecore_IMF_Mouse_Flags;
 228
 229    typedef enum
 230      {
 231         ECORE_IMF_INPUT_MODE_ALPHA        = 1 << 0,
 232         ECORE_IMF_INPUT_MODE_NUMERIC      = 1 << 1,
 233         ECORE_IMF_INPUT_MODE_SPECIAL      = 1 << 2,
 234         ECORE_IMF_INPUT_MODE_HEXA         = 1 << 3,
 235         ECORE_IMF_INPUT_MODE_TELE         = 1 << 4,
 236         ECORE_IMF_INPUT_MODE_FULL         = (ECORE_IMF_INPUT_MODE_ALPHA | ECORE_IMF_INPUT_MODE_NUMERIC | ECORE_IMF_INPUT_MODE_SPECIAL),
 237         ECORE_IMF_INPUT_MODE_INVISIBLE    = 1 << 29,
 238         ECORE_IMF_INPUT_MODE_AUTOCAP      = 1 << 30
 239      } Ecore_IMF_Input_Mode;
 240
 241    struct _Ecore_IMF_Event_Preedit_Start
 242      {
 243         Ecore_IMF_Context *ctx;
 244      };
 245
 246    struct _Ecore_IMF_Event_Preedit_End
 247      {
 248         Ecore_IMF_Context *ctx;
 249      };
 250
 251    struct _Ecore_IMF_Event_Preedit_Changed
 252      {
 253         Ecore_IMF_Context *ctx;
 254      };
 255
 256    struct _Ecore_IMF_Event_Commit
 257      {
 258         Ecore_IMF_Context *ctx;
 259         char *str;
 260      };
 261
 262    struct _Ecore_IMF_Event_Delete_Surrounding
 263      {
 264         Ecore_IMF_Context *ctx;
 265         int offset;
 266         int n_chars;
 267      };
 268
 269    struct _Ecore_IMF_Event_Mouse_Down
 270      {
 271         int button;                             /**< The button which has been pressed */
 272         struct {
 273              int x, y;
 274         } output;
 275         struct {
 276              int x, y;
 277         } canvas;
 278         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 279         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 280         Ecore_IMF_Mouse_Flags        flags;     /**< The flags corresponding the mouse click (single, double or triple click) */
 281         unsigned int                 timestamp; /**< The timestamp when the event occured */
 282      };
 283
 284    struct _Ecore_IMF_Event_Mouse_Up
 285      {
 286         int button;                             /**< The button which has been pressed */
 287         struct {
 288              int x, y;
 289         } output;
 290         struct {
 291              int x, y;
 292         } canvas;
 293         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 294         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 295         Ecore_IMF_Mouse_Flags        flags;     /**< The flags corresponding the mouse click (single, double or triple click) */
 296         unsigned int                 timestamp; /**< The timestamp when the event occured */
 297      };
 298
 299    struct _Ecore_IMF_Event_Mouse_In
 300      {
 301         int buttons;
 302         struct {
 303              int x, y;
 304         } output;
 305         struct {
 306              int x, y;
 307         } canvas;
 308         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 309         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 310         unsigned int                 timestamp; /**< The timestamp when the event occured */
 311      };
 312
 313    struct _Ecore_IMF_Event_Mouse_Out
 314      {
 315         int buttons;
 316         struct {
 317              int x, y;
 318         } output;
 319         struct {
 320              int x, y;
 321         } canvas;
 322         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 323         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 324         unsigned int                 timestamp; /**< The timestamp when the event occured */
 325      };
 326
 327    struct _Ecore_IMF_Event_Mouse_Move
 328      {
 329         int buttons;
 330         struct {
 331              struct {
 332                   int x, y;
 333              } output;
 334              struct {
 335                   int x, y;
 336              } canvas;
 337         } cur, prev;
 338         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 339         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 340         unsigned int                 timestamp; /**< The timestamp when the event occured */
 341      };
 342
 343    struct _Ecore_IMF_Event_Mouse_Wheel
 344      {
 345         int direction;                         /* 0 = default up/down wheel */
 346         int z;                                 /* ...,-2,-1 = down, 1,2,... = up */
 347         struct {
 348              int x, y;
 349         } output;
 350         struct {
 351              int x, y;
 352         } canvas;
 353         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 354         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 355         unsigned int                 timestamp; /**< The timestamp when the event occured */
 356      };
 357
 358    struct _Ecore_IMF_Event_Key_Down
 359      {
 360         const char                  *keyname;   /**< The string name of the key pressed */
 361         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 362         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 363         const char                  *key;       /**< The logical key : (eg shift+1 == exclamation) */
 364         const char                  *string;    /**< A UTF8 string if this keystroke has produced a visible string to be ADDED */
 365         const char                  *compose;   /**< A UTF8 string if this keystroke has modified a string in the middle of being composed - this string replaces the previous one */
 366         unsigned int                 timestamp; /**< The timestamp when the event occured */
 367      };
 368
 369    struct _Ecore_IMF_Event_Key_Up
 370      {
 371         const char                  *keyname;   /**< The string name of the key pressed */
 372         Ecore_IMF_Keyboard_Modifiers modifiers; /**< The keyboard modifiers active when the event has been emitted */
 373         Ecore_IMF_Keyboard_Locks     locks;     /**< The keyboard locks active when the event has been emitted */
 374         const char                  *key;       /**< The logical key : (eg shift+1 == exclamation) */
 375         const char                  *string;    /**< A UTF8 string if this keystroke has produced a visible string to be ADDED */
 376         const char                  *compose;   /**< A UTF8 string if this keystroke has modified a string in the middle of being composed - this string replaces the previous one */
 377         unsigned int                 timestamp; /**< The timestamp when the event occured */
 378      };
 379
 380    union _Ecore_IMF_Event
 381      {
 382         Ecore_IMF_Event_Mouse_Down mouse_down;
 383         Ecore_IMF_Event_Mouse_Up mouse_up;
 384         Ecore_IMF_Event_Mouse_In mouse_in;
 385         Ecore_IMF_Event_Mouse_Out mouse_out;
 386         Ecore_IMF_Event_Mouse_Move mouse_move;
 387         Ecore_IMF_Event_Mouse_Wheel mouse_wheel;
 388         Ecore_IMF_Event_Key_Down key_down;
 389         Ecore_IMF_Event_Key_Up key_up;
 390      };
 391
 392    typedef enum
 393      {
 394         ECORE_IMF_PREEDIT_TYPE_NONE = 0,
 395         ECORE_IMF_PREEDIT_TYPE_SUB1 = 1,
 396         ECORE_IMF_PREEDIT_TYPE_SUB2 = 2,
 397         ECORE_IMF_PREEDIT_TYPE_SUB3 = 3
 398      } Ecore_IMF_Preedit_Type;
 399
 400    typedef struct _Ecore_IMF_Preedit_Attr Ecore_IMF_Preedit_Attr;
 401
 402    struct _Ecore_IMF_Preedit_Attr
 403      {
 404         Ecore_IMF_Preedit_Type preedit_type;
 405         unsigned int start_index;
 406         unsigned int end_index;
 407      };
 408
 409    struct _Ecore_IMF_Context_Class
 410      {
 411         void (*add)                 (Ecore_IMF_Context *ctx);
 412         void (*del)                 (Ecore_IMF_Context *ctx);
 413         void (*client_window_set)   (Ecore_IMF_Context *ctx, void *window);
 414         void (*client_canvas_set)   (Ecore_IMF_Context *ctx, void *canvas);
 415         void (*show)                (Ecore_IMF_Context *ctx);
 416         void (*hide)                (Ecore_IMF_Context *ctx);
 417         void (*preedit_string_get)  (Ecore_IMF_Context *ctx, char **str, int *cursor_pos);
 418         void (*focus_in)            (Ecore_IMF_Context *ctx);
 419         void (*focus_out)           (Ecore_IMF_Context *ctx);
 420         void (*reset)               (Ecore_IMF_Context *ctx);
 421         void (*cursor_position_set) (Ecore_IMF_Context *ctx, int cursor_pos);
 422         void (*use_preedit_set)     (Ecore_IMF_Context *ctx, Eina_Bool use_preedit);
 423         void (*input_mode_set)      (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Mode input_mode);
 424         Eina_Bool (*filter_event)   (Ecore_IMF_Context *ctx, Ecore_IMF_Event_Type type, Ecore_IMF_Event *event);
 425
 426         /* Input Panel Control APIs */
 427         void (*control_panel_show)   (Ecore_IMF_Context *ctx);
 428         void (*control_panel_hide)   (Ecore_IMF_Context *ctx);
 429
 430         void (*input_panel_layout_set)         (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Layout layout);
 431         Ecore_IMF_Input_Panel_Layout (*input_panel_layout_get)         (Ecore_IMF_Context *ctx);
 432
 433         void (*input_panel_language_set)       (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Lang lang);
 434         Ecore_IMF_Input_Panel_Lang (*input_panel_language_get) (Ecore_IMF_Context *ctx);
 435
 436         void (*input_panel_imdata_set)         (Ecore_IMF_Context *ctx, const char* data, int len);
 437         void (*input_panel_imdata_get)         (Ecore_IMF_Context *ctx, char* data, int *len);
 438
 439         void (*input_panel_use_effect_set)     (Ecore_IMF_Context *ctx, Eina_Bool use_effect);
 440         void (*input_panel_orient_set)         (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Orient orientation);
 441
 442         void (*input_panel_move) (Ecore_IMF_Context *ctx, int x, int y);
 443         void (*input_panel_geometry_get)       (Ecore_IMF_Context *ctx, int *x, int *y, int *w, int *h);
 444         void (*input_panel_private_key_set)    (Ecore_IMF_Context *ctx, int layout_index, int key_index, const char *img_path, const char* label, const char* value);
 445         void (*input_panel_key_disabled_set)   (Ecore_IMF_Context *ctx, int layout_index, int key_index, Eina_Bool disabled);
 446
 447         void (*input_panel_reset)              (Ecore_IMF_Context *ctx); /* Same as reset to default property*/
 448         Ecore_IMF_Input_Panel_State (*input_panel_state_get)          (Ecore_IMF_Context *ctx);
 449
 450         /* CallBack APIs  */
 451         void (*input_panel_event_callback_add) (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Event type, void (*pEventCallBackFunc) (void *data, Ecore_IMF_Context *ctx, int value), void *data);
 452         void (*input_panel_event_callback_del) (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Event type, void (*pEventCallbackFunc) (void *data, Ecore_IMF_Context *ctx, int value));
 453
 454         /* ISF related APIs */
 455         int (*ise_get_ise_language)       (Ecore_IMF_Context *ctx, const char* input_panel_name, char*** langlist);
 456         int (*ise_set_isf_language)       (Ecore_IMF_Context *ctx, const char* lang);
 457         int (*ise_get_active_isename)     (Ecore_IMF_Context *ctx, char* name);       /**< will be deprecated */
 458         int (*ise_set_active_ise_by_name) (Ecore_IMF_Context *ctx, const char* name); /**< will be deprecated */
 459         int (*ise_set_active_ise_by_uuid) (Ecore_IMF_Context *ctx, const char* uuid); /**< will be deprecated */
 460         int (*ise_get_iselist)            (Ecore_IMF_Context *ctx, char*** iselist);  /**< will be deprecated */
 461         void (*input_panel_caps_mode_set) (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Caps_Mode mode);
 462
 463         void (*preedit_string_with_attributes_get) (Ecore_IMF_Context *ctx, char **str, Eina_List **attrs, int *cursor_pos);
 464      };
 465
 466    struct _Ecore_IMF_Context_Info
 467      {
 468         const char *id;              /* ID */
 469         const char *description;     /* Human readable description */
 470         const char *default_locales; /* Languages for which this context is the default, separated by : */
 471         const char *canvas_type;     /* The canvas type used by the input method. Eg.: evas */
 472         int         canvas_required; /* Whether the canvas usage is required for this input method */
 473      };
 474
 475    EAPI int                           ecore_imf_init(void);
 476    EAPI int                           ecore_imf_shutdown(void);
 477
 478    EAPI void                          ecore_imf_module_register(const Ecore_IMF_Context_Info *info, Ecore_IMF_Context *(*imf_module_create)(void), Ecore_IMF_Context *(*imf_module_exit)(void));
 479
 480    EAPI Eina_List                    *ecore_imf_context_available_ids_get(void);
 481    EAPI Eina_List                    *ecore_imf_context_available_ids_by_canvas_type_get(const char *canvas_type);
 482    EAPI const char                   *ecore_imf_context_default_id_get(void);
 483    EAPI const char                   *ecore_imf_context_default_id_by_canvas_type_get(const char *canvas_type);
 484    EAPI const Ecore_IMF_Context_Info *ecore_imf_context_info_by_id_get(const char *id);
 485
 486    EAPI Ecore_IMF_Context            *ecore_imf_context_add(const char *id);
 487    EAPI const Ecore_IMF_Context_Info *ecore_imf_context_info_get(Ecore_IMF_Context *ctx);
 488    EAPI void                          ecore_imf_context_del(Ecore_IMF_Context *ctx);
 489    EAPI void                          ecore_imf_context_client_window_set(Ecore_IMF_Context *ctx, void *window);
 490    EAPI void*                         ecore_imf_context_client_window_get(Ecore_IMF_Context *ctx);
 491    EAPI void                          ecore_imf_context_client_canvas_set(Ecore_IMF_Context *ctx, void *canvas);
 492    EAPI void*                         ecore_imf_context_client_canvas_get(Ecore_IMF_Context *ctx);
 493    EINA_DEPRECATED EAPI void          ecore_imf_context_show(Ecore_IMF_Context *ctx);
 494    EINA_DEPRECATED EAPI void          ecore_imf_context_hide(Ecore_IMF_Context *ctx);
 495    EAPI void                          ecore_imf_context_preedit_string_get(Ecore_IMF_Context *ctx, char **str, int *cursor_pos);
 496    EAPI void                          ecore_imf_context_preedit_string_with_attributes_get(Ecore_IMF_Context *ctx, char **str, Eina_List **attrs, int *cursor_pos);
 497    EAPI void                          ecore_imf_context_focus_in(Ecore_IMF_Context *ctx);
 498    EAPI void                          ecore_imf_context_focus_out(Ecore_IMF_Context *ctx);
 499    EAPI void                          ecore_imf_context_reset(Ecore_IMF_Context *ctx);
 500    EAPI void                          ecore_imf_context_cursor_position_set(Ecore_IMF_Context *ctx, int cursor_pos);
 501    EAPI void                          ecore_imf_context_use_preedit_set(Ecore_IMF_Context *ctx, Eina_Bool use_preedit);
 502    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);
 503    EINA_DEPRECATED EAPI void          ecore_imf_context_input_mode_set(Ecore_IMF_Context *ctx, Ecore_IMF_Input_Mode input_mode);
 504    EINA_DEPRECATED EAPI Ecore_IMF_Input_Mode          ecore_imf_context_input_mode_get(Ecore_IMF_Context *ctx);
 505    EAPI Eina_Bool                     ecore_imf_context_filter_event(Ecore_IMF_Context *ctx, Ecore_IMF_Event_Type type, Ecore_IMF_Event *event);
 506
 507    /* plugin specific functions */
 508    EAPI Ecore_IMF_Context            *ecore_imf_context_new(const Ecore_IMF_Context_Class *ctxc);
 509    EAPI void                          ecore_imf_context_data_set(Ecore_IMF_Context *ctx, void *data);
 510    EAPI void                         *ecore_imf_context_data_get(Ecore_IMF_Context *ctx);
 511    EAPI Eina_Bool                     ecore_imf_context_surrounding_get(Ecore_IMF_Context *ctx, char **text, int *cursor_pos);
 512    EAPI void                          ecore_imf_context_preedit_start_event_add(Ecore_IMF_Context *ctx);
 513    EAPI void                          ecore_imf_context_preedit_end_event_add(Ecore_IMF_Context *ctx);
 514    EAPI void                          ecore_imf_context_preedit_changed_event_add(Ecore_IMF_Context *ctx);
 515    EAPI void                          ecore_imf_context_commit_event_add(Ecore_IMF_Context *ctx, const char *str);
 516    EAPI void                          ecore_imf_context_delete_surrounding_event_add(Ecore_IMF_Context *ctx, int offset, int n_chars);
 517
 518    /**
 519     * Show the current active ISE with given state.
 520     * To use this API application should include Ecore_IMF.h header file.
 521     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 522     * @param ctx context used to map real loaded APIs
 523     * @ingroup Ecore_IMF_Context_IMControl_Group
 524     * @code
 525     * #include <Ecore_IMF.h>
 526     *
 527     * static void entry_application(appdata * ad)
 528     * {
 529     *     Evas_Object *en;
 530     *     en = elm_entry_add(ad->win_main);
 531     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
 532     *     if(imf_context)
 533     *     {
 534     *         // show input panel window
 535     *         ecore_imf_context_input_panel_show (imf_context);
 536     *     }
 537     * }
 538     *
 539     * @endcode
 540     */
 541    EAPI void ecore_imf_context_input_panel_show(Ecore_IMF_Context *ctx);
 542
 543    /**
 544     * Hide the current active ISE.
 545     * To use this API application should include Ecore_IMF.h header file.
 546     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 547     * @param ctx context used to map real loaded APIs
 548     * @ingroup Ecore_IMF_Context_IMControl_Group
 549     * @code
 550     * #include <Ecore_IMF.h>
 551     *
 552     * static void button_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 553     * {
 554     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(obj);
 555     *
 556     *     if(imf_context)
 557     *     {
 558     *         ecore_imf_context_input_panel_hide (imf_context);
 559     *     }
 560     * }
 561     *
 562     * static void entry_application(appdata * ad)
 563     * {
 564     *     Evas_Object *en;
 565     *     en = elm_entry_add(ad->win_main);
 566     *     evas_object_smart_callback_add(en, "clicked", button_clicked_cb, NULL);
 567     * }
 568     *
 569     * @endcode
 570     */
 571    EAPI void ecore_imf_context_input_panel_hide(Ecore_IMF_Context *ctx);
 572
 573    /**
 574     * Show control panel.
 575     * @param ctx context used to map real loaded APIs
 576     * @ingroup Ecore_IMF_Context_IMControl_Group
 577     *
 578     * ISE control panel shows ISE list and provides setup of each ISE
 579     */
 580    EAPI void ecore_imf_context_control_panel_show (Ecore_IMF_Context *ctx);
 581
 582    /**
 583     * Hide control panel.
 584     * @param ctx context used to map real loaded APIs
 585     * @ingroup Ecore_IMF_Context_IMControl_Group
 586     *
 587     * ISE control panel shows ISE list and provides setup of each ISE
 588     */
 589    EAPI void ecore_imf_context_control_panel_hide (Ecore_IMF_Context *ctx);
 590
 591    /**
 592     * Set ISE Language before show ISE.
 593     * @param ctx context used to map real loaded APIs
 594     * @param lang see Ecore_IMF_Input_Panel_Lang
 595     * @ingroup Ecore_IMF_Context_IMControl_Group
 596     * THIS API IS NOT SUPPORTED NOW
 597     */
 598    EAPI void ecore_imf_context_input_panel_language_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Lang lang);
 599
 600    /**
 601     * Get ISE Language of current active ISE.
 602     * @param ctx context used to map real loaded APIs
 603     * @return Ecore_IMF_Input_Panel_Lang
 604     * @ingroup Ecore_IMF_Context_IMControl_Group
 605     * THIS API IS NOT SUPPORTED NOW
 606     */
 607    EAPI Ecore_IMF_Input_Panel_Lang ecore_imf_context_input_panel_language_get (Ecore_IMF_Context *ctx);
 608
 609    /**
 610     * Set keyboard language.
 611     * @param ctx context used to map real loaded APIs
 612     * @param lang see Ecore_IMF_Input_Panel_Lang
 613     * @ingroup Ecore_IMF_Context_IMControl_Group
 614     * THIS API IS NOT SUPPORTED NOW
 615     */
 616    EAPI void ecore_imf_context_keyboard_language_set (Ecore_IMF_Context *ctx, Ecore_IMF_Keyboard_Lang lang);
 617
 618    /**
 619     * Get keyboard language.
 620     * @param ctx context used to map real loaded APIs
 621     * @return Ecore_IMF_Input_Panel_Lang
 622     * @ingroup Ecore_IMF_Context_IMControl_Group
 623     * THIS API IS NOT SUPPORTED NOW
 624     */
 625    EAPI Ecore_IMF_Keyboard_Lang ecore_imf_context_keyboard_language_get (Ecore_IMF_Context *ctx);
 626
 627    /**
 628     * Get ISE Language of given ISE. -- Not supported for now --
 629     * @ingroup Ecore_IMF_Context_IMControl_Group
 630     */
 631    EAPI int ecore_imf_context_ise_get_ise_language (Ecore_IMF_Context *ctx, const char* ise_name, char ***langlist);
 632
 633    /**
 634     * Set ISF Language. -- Not supported for now --
 635     * @ingroup Ecore_IMF_Context_IMControl_Group
 636     */
 637    EAPI void ecore_imf_context_ise_set_isf_language (Ecore_IMF_Context *ctx, const char* lang);
 638
 639    /**
 640     * Set ISE Specific data before show ISE.
 641     * To use this API application should include Ecore_IMF.h header file.
 642     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 643     * @param ctx context used to map real loaded APIs
 644     * @param data data pointer
 645     * @param len data length
 646     * @ingroup Ecore_IMF_Context_IMControl_Group
 647     *
 648     * this API is used by applications to deliver specific data to ISE.
 649     * the data format MUST be negotiated by both application and ISE negotiate.
 650     *
 651     * @code
 652     * #include <Ecore_IMF.h>
 653     *
 654     * static void create_entry(struct appdata *ad)
 655     * {
 656     *     char *im_data="application sample imdata";
 657     *     Evas_Object *en;
 658     *
 659     *     en = elm_entry_add(ad->layout_main);
 660     *     elm_layout_content_set(ad->layout_main, "entry", en);
 661     *
 662     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
 663     *
 664     *     if (imf_context)
 665     *     {
 666     *         ecore_imf_context_input_panel_imdata_set (imf_context, im_data, strlen(im_data)+1);
 667     *     }
 668     * }
 669     * @endcode
 670     */
 671    EAPI void ecore_imf_context_input_panel_imdata_set       (Ecore_IMF_Context *ctx, const char * data, int len);
 672
 673    /**
 674     * Get ISE Specific data of current active ISE.
 675     * To use this API application should include Ecore_IMF.h header file.
 676     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 677     * @param ctx context used to map real loaded APIs
 678     * @param data data pointer
 679     * @param len data length
 680     * @ingroup Ecore_IMF_Context_IMControl_Group
 681     * @code
 682     * #include <Ecore_IMF.h>
 683     *
 684     * static void create_entry(struct appdata *ad)
 685     * {
 686     *     int len = 256;
 687     *     char *im_data = (char*) malloc (len);
 688     *
 689     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(ad->entry);
 690     *
 691     *     if (imf_context)
 692     *     {
 693     *         ecore_imf_context_input_panel_imdata_get (imf_context, im_data, &len);
 694     *     }
 695     *
 696     *     free(im_data);
 697     * }
 698     * @endcode
 699     */
 700    EAPI void ecore_imf_context_input_panel_imdata_get       (Ecore_IMF_Context *ctx, char *data, int *len);
 701
 702    /**
 703     * Set ISE whether animation effect is shown or not.
 704     * To use this API application should include Ecore_IMF.h header file.
 705     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 706     * @param ctx context used to map real loaded APIs
 707     * @param use_effect whether animation effect is shown or not
 708     * @ingroup Ecore_IMF_Context_IMControl_Group
 709     *
 710     * this API is used by applications to deliver specific data to ISE.
 711     * the data format MUST be negotiated by both application and ISE negotiate.
 712     *
 713     * @code
 714     * #include <Ecore_IMF.h>
 715     *
 716     * static void create_entry(struct appdata *ad)
 717     * {
 718     *     Evas_Object *en;
 719     *
 720     *     en = elm_entry_add(ad->layout_main);
 721     *     elm_layout_content_set(ad->layout_main, "entry", en);
 722     *
 723     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
 724     *
 725     *     if (imf_context)
 726     *     {
 727     *         ecore_imf_context_input_panel_use_effect_set (imf_context, EINA_FALSE); // turn off the animation effect when input panel is appeared.
 728     *     }
 729     * }
 730     * @endcode
 731     */
 732    EAPI void ecore_imf_context_input_panel_use_effect_set           (Ecore_IMF_Context *ctx, Eina_Bool use_effect);
 733
 734    /**
 735     * Get whether ISE supports animation effect or not when it is shown or hidden.
 736     * To use this API application should include Ecore_IMF.h header file.
 737     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 738     * @param ctx context used to map real loaded APIs
 739     * @param use_effect whether animation effect is shown or not
 740     * @ingroup Ecore_IMF_Context_IMControl_Group
 741     *
 742     * this API is used by applications to deliver specific data to ISE.
 743     * the data format MUST be negotiated by both application and ISE negotiate.
 744     *
 745     * @code
 746     * #include <Ecore_IMF.h>
 747     *
 748     * static Eina_Bool get_effect_info(struct appdata *ad)
 749     * {
 750     *     Eina_Bool use_effect = EINA_TRUE;
 751     *
 752     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(ad->entry);
 753     *
 754     *     if (imf_context)
 755     *     {
 756     *         use_effect = ecore_imf_context_input_panel_use_effect_get (imf_context);
 757     *     }
 758     *
 759     *     return use_effect;
 760     * }
 761     * @endcode
 762     */
 763    EAPI Eina_Bool ecore_imf_context_input_panel_use_effect_get      (Ecore_IMF_Context *ctx);
 764
 765    /**
 766     * Get ISE position of current active ISE.
 767     * To use this API application should include Ecore_IMF.h header file.
 768     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 769     * @param ctx context used to map real loaded APIs
 770     * @param x top-left x co-ordinate of rectangle;
 771     * @param y top-left y co-ordinate of rectangle;
 772     * @param w width of rectangle ;
 773     * @param h height of rectangle;
 774     * @ingroup Ecore_IMF_Context_IMControl_Group
 775     * @code
 776     * #include <Ecore_IMF.h>
 777     *
 778     * int get_geometry(struct appdata *ad)
 779     * {
 780     *    Ecore_IMF_Context *imf_context = NULL;
 781     *    int x, y, w, h;
 782     *    imf_context = elm_entry_imf_context_get (ad->entry);
 783     *    if (imf_context)
 784     *    {
 785     *        ecore_imf_context_input_panel_geometry_get (imf_context, &x, &y, &w, &h);
 786     *        //here application can get window size rect
 787     *        printf ("x=%d \n", x);
 788     *        printf ("y=%d \n", y);
 789     *        printf ("width=%d \n", w);
 790     *        printf ("height=%d \n", h);
 791     *    }
 792     * @endcode
 793     */
 794    EAPI void ecore_imf_context_input_panel_geometry_get  (Ecore_IMF_Context *ctx, int *x, int *y, int *w, int *h);
 795
 796    /**
 797     * Set ISE private key before show ISE.
 798     * To use this API application should include Ecore_IMF.h header file.
 799     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 800     * Since the second parameter of this API requires a layout index, so before using this API application has to set a specific layout and that layout index
 801     * should be passed in the 2nd argument of this API(see sample code).
 802     * @param ctx context used to map real loaded APIs
 803     * @param layout_index index of layout page to be set
 804     * @param key_index index of key to be set
 805     * @param label text label to be appeared on private key
 806     * @param value value of key, If NULL it will use original value of key
 807     * @ingroup Ecore_IMF_Context_IMControl_Group
 808     * @code
 809     *
 810     * #include <Ecore_IMF.h>
 811     *
 812     * static void create_entry(struct appdata *ad)
 813     * {
 814     *     Evas_Object *en;
 815     *
 816     *     en = elm_entry_add(ad->layout_main);
 817     *
 818     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
 819     *
 820     *     if (imf_context)
 821     *     {
 822     *         ecore_imf_context_input_panel_private_key_set (imf_context, layout, 0, NULL, "www", -1, "www");
 823     *     }
 824     * }
 825     * @endcode
 826     */
 827    EAPI void ecore_imf_context_input_panel_private_key_set  (Ecore_IMF_Context *ctx, int layout_index, int key_index, const char *img_path, const char* label, int key_value, const char* key_string);
 828
 829    EAPI Eina_List *ecore_imf_context_input_panel_private_key_list_get  (Ecore_IMF_Context *ctx);
 830
 831    /**
 832     * Set ISE Layout before show ISE.
 833     * To use this API application should include Ecore_IMF.h header file.
 834     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 835     * @param ctx context used to map real loaded APIs
 836     * @param layout see ECORE_IMF_INPUT_PANEL_LAYOUT
 837     * @ingroup Ecore_IMF_Context_IMControl_Group
 838     * @code
 839     * #include <Ecore_IMF.h>
 840     *
 841     * static void create_entry(struct appdata *ad)
 842     * {
 843     *     en = elm_entry_add(ad->layout_main);
 844     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
 845     *
 846     *     if (imf_context)
 847     *     {
 848     *         ecore_imf_context_input_panel_layout_set (imf_context, ECORE_IMF_INPUT_PANEL_LAYOUT_EMAIL);
 849     *     }
 850     * }
 851     * @endcode
 852     */
 853    EAPI void ecore_imf_context_input_panel_layout_set  (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Layout layout);
 854
 855    /**
 856     * Get ISE Layout of current active ISE.
 857     * To use this API application should include Ecore_IMF.h header file.
 858     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 859     * @param ctx context used to map real loaded APIs
 860     * @return layout see ECORE_IMF_INPUT_PANEL_LAYOUT
 861     * @ingroup Ecore_IMF_Context_IMControl_Group
 862     * @code
 863     * #include <Ecore_IMF.h>
 864     *
 865     * static void layout_get(struct appdata *ad)
 866     * {
 867     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(ad->entry);
 868     *
 869     *     if (imf_context)
 870     *     {
 871     *         layout = ecore_imf_context_input_panel_layout_get (imf_context);
 872     *     }
 873     * }
 874     * @endcode
 875     */
 876    EAPI Ecore_IMF_Input_Panel_Layout ecore_imf_context_input_panel_layout_get  (Ecore_IMF_Context *ctx);
 877
 878    /**
 879     * Reset ISE Context including its Style.
 880     * To use this API application should include Ecore_IMF.h header file.
 881     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 882     * This is special function that should be called before calling any ecore_imf_context_set*** APIs to restore all default properties of ISE.
 883     * @ingroup Ecore_IMF_Context_IMControl_Group
 884     *
 885     * NOTE: This API MUST be called before calling ecore_imf_context_input_panel_show().
 886     */
 887    EAPI void ecore_imf_context_input_panel_reset       (Ecore_IMF_Context *ctx);        /* Same as reset to default property*/
 888
 889    /**
 890     * Set ISE screen orientation.
 891     * To use this API application should include Ecore_IMF.h header file.
 892     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 893     * To show the keypad in landscape mode application should first call this API with 2nd parameter as 90 or 270.
 894     * After then only application should call ecore_imf_context_input_panel_show() function.
 895     * @ingroup Ecore_IMF_Context_IMControl_Group
 896     * @code
 897     * #include <Ecore_IMF.h>
 898     *
 899     * static void create_entry(struct appdata *ad)
 900     * {
 901     *     en = elm_entry_add(ad->layout_main);
 902     *     elm_layout_content_set(ad->layout_main, "entry", en);
 903     *
 904     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
 905     *     int degree = 90; // the degree value can be either 90/270 for landscape mode and normal portrait mode 0/360.
 906     *
 907     *     if (imf_context)
 908     *     {
 909     *         // the orient value can be
 910     *         // ECORE_IMF_INPUT_PANEL_ORIENT_NONE,
 911     *         // ECORE_IMF_INPUT_PANEL_ORIENT_90_CW // Clockwise
 912     *         // ECORE_IMF_INPUT_PANEL_ORIENT_180,
 913     *         // ECORE_IMF_INPUT_PANEL_ORIENT_90_CCW // CounterClockwise
 914     *         ecore_imf_context_input_panel_orient_set(imf_context, ECORE_IMF_INPUT_PANEL_ORIENT_90_CW);
 915     *     }
 916     * }
 917     */
 918    EAPI void ecore_imf_context_input_panel_orient_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Orient  orientation);
 919
 920    /**
 921     * Get Input panel orientation.
 922     * To use this API application should include Ecore_IMF.h header file.
 923     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 924     * To show the keypad in landscape mode application should first call this API with 2nd parameter as 90 or 270.
 925     * After then only application should call ecore_imf_context_input_panel_show() function.
 926     * @ingroup Ecore_IMF_Context_IMControl_Group
 927     * @code
 928     * #include <Ecore_IMF.h>
 929
 930     * void get_orient (struct appdata *ad)
 931     * {
 932     *     Ecore_IMF_Input_Panel_Orient orient;
 933     *     ad->entry = elm_entry_add(ad->layout_main);
 934     *     elm_entry_input_panel_layout_set(ad->entry, ELM_INPUT_PANEL_LAYOUT_URL);
 935     *     imf_context = elm_entry_imf_context_get (ad->entry);
 936     *     if (imf_context)
 937     *     {
 938     *         orient = ecore_imf_context_input_panel_orient_get (imf_context);
 939     *     }
 940     *
 941     *     switch (orient)
 942     *     {
 943     *     case ECORE_IMF_INPUT_PANEL_ORIENT_NONE:
 944     *         printf("0 degree\n");
 945     *         break;
 946     *     case ECORE_IMF_INPUT_PANEL_ORIENT_90_CW:
 947     *         printf("90 degree clockwise\n");
 948     *         break;
 949     *     case ECORE_IMF_INPUT_PANEL_ORIENT_180:
 950     *         printf("90 degree clockwise\n");
 951     *         break;
 952     *     case ECORE_IMF_INPUT_PANEL_ORIENT_90_CCW:
 953     *         printf("90 degree counter-clockwise\n");
 954     *         break;
 955     *     }
 956     * }
 957     */
 958
 959    EAPI Ecore_IMF_Input_Panel_Orient ecore_imf_context_input_panel_orient_get (Ecore_IMF_Context *ctx);
 960
 961    /**
 962     * Get name of current active ISE.
 963     * To use this API application should include Ecore_IMF.h header file.
 964     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 965     * @param ctx context used to map real loaded APIs
 966     * @param name ISE name to be got
 967     * @ingroup Ecore_IMF_Context_IMControl_Group
 968     * @code
 969     * #include <Ecore_IMF.h>
 970     *
 971     * static void create_entry(struct appdata *ad)
 972     * {
 973     *     int len = 256;
 974     *     char *isename = (char*) malloc (len);
 975     *     memset(isename, '\0', sizeof(isename));
 976     *
 977     *     Ecore_IMF_Context *imf_context = NULL;
 978     *     imf_context = elm_entry_imf_context_get(obj);
 979     *
 980     *     if (imf_context)
 981     *     {
 982     *         ecore_imf_context_ise_get_active_isename (imf_context, isename);
 983     *         printf("get isename=[%s]\n", isename);
 984     *     }
 985     * }
 986     * @endcode
 987     */
 988    EAPI void ecore_imf_context_ise_get_active_isename     (Ecore_IMF_Context *ctx, char* name);
 989
 990    /**
 991     * Set ISE by its name.
 992     * To use this API application should include Ecore_IMF.h header file.
 993     * Before calling this API, every application should call ecore_imf_init() to initialize the ecore_imf shared library.
 994     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
 995     * @param ctx context used to map real loaded APIs
 996     * @param name ISE name to be set
 997     * @ingroup Ecore_IMF_Context_IMControl_Group
 998     * @code
 999     * #include <Ecore_IMF.h>
1000     *
1001     * static void create_entry(struct appdata *ad)
1002     * {
1003     *     ecore_imf_init();
1004     *
1005     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(obj);
1006     *
1007     *     if (imf_context)
1008     *     {
1009     *         ecore_imf_context_ise_set_active_ise_by_name (imf_context, "Input Pad");
1010     *     }
1011     *
1012     *     //do imf related things
1013     *
1014     *     ecore_imf_shutdown();
1015     *
1016     *     //do imf irrelated things
1017     * }
1018     * @endcode
1019     */
1020    EAPI void ecore_imf_context_ise_set_active_ise_by_name (Ecore_IMF_Context *ctx, const char* name);
1021
1022    /**
1023     * Set ISE by its uuid.
1024     * To use this API application should include Ecore_IMF.h header file.
1025     * Before calling this API, every application should call ecore_imf_init() to initialize the ecore_imf shared library.
1026     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
1027     * @param ctx context used to map real loaded APIs
1028     * @param uuid ISE uuid to be set
1029     * @ingroup Ecore_IMF_Context_IMControl_Group
1030     * @code
1031     * #include <Ecore_IMF.h>
1032     *
1033     * static void create_entry(struct appdata *ad)
1034     * {
1035     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(obj);
1036     *
1037     *     if (imf_context)
1038     *     {
1039     *         ecore_imf_context_ise_set_active_ise_by_uuid (imf_context, "ff110940-b8f0-4062-9ff6-a84f4f3575c0");
1040     *         ecore_imf_context_input_panel_show (imf_context);
1041     *     }
1042     * }
1043     * @endcode
1044     */
1045    EAPI void ecore_imf_context_ise_set_active_ise_by_uuid (Ecore_IMF_Context *ctx, const char* uuid);
1046
1047    /**
1048     * Get list of ISEs.
1049     * To use this API application should include Ecore_IMF.h header file.
1050     * Before calling this API, every application should call ecore_imf_init() to initialize the ecore_imf shared library.
1051     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
1052     * @param ctx context used to map real loaded APIs
1053     * @param iselist pointer to the list to be got.
1054     * @return  int ise counter of iselist
1055     * @ingroup Ecore_IMF_Context_IMControl_Group
1056     * @code
1057     * #include <Ecore_IMF.h>
1058     *
1059     * static void create_entry(struct appdata *ad)
1060     * {
1061     *     ecore_imf_init();
1062     *
1063     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(obj);
1064     *
1065     *     if (imf_context)
1066     *     {
1067     *         char** iselist;
1068     *         int count,i;
1069     *         count = ecore_imf_context_input_panel_get_iselist(imf_context, &iselist);
1070     *         printf("get_iselist : count[%d] ", count);
1071     *         for (i=0;i<count;i++)
1072     *             printf("[%d:%s] ", i, iselist[i]);
1073     *     }
1074     *
1075     *     //do imf related things
1076     *
1077     *     ecore_imf_shutdown();
1078     *
1079     *     //do imf irrelated things
1080     * }
1081     * @endcode
1082     */
1083    EAPI int ecore_imf_context_ise_get_iselist (Ecore_IMF_Context *ctx, char*** iselist);
1084
1085    /**
1086     * Get state of current active ISE.
1087     * To use this API application should include Ecore_IMF.h header file.
1088     * Before calling this API, every application should call ecore_imf_init() to initialize the ecore_imf shared library.
1089     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
1090     * @param ctx context used to map real loaded APIs
1091     * @param state see ISE_STATE
1092     * @ingroup Ecore_IMF_Context_IMControl_Group
1093     * @code
1094     * #include <Ecore_IMF.h>
1095     *
1096     * static void input_panel_state_get(struct appdata *ad)
1097     * {
1098     *     Ecore_IMF_Input_Panel_State state;
1099     *
1100     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(ad->entry);
1101     *
1102     *     if (imf_context)
1103     *     {
1104     *         state = ecore_imf_context_input_panel_state_get (imf_context);
1105     *         //here u can see what the current state is
1106     *         printf("the current state of ISE is %d", state);
1107     *     }
1108     * }
1109     * @endcode
1110     */
1111    EAPI Ecore_IMF_Input_Panel_State ecore_imf_context_input_panel_state_get          (Ecore_IMF_Context *ctx);
1112
1113    /**
1114     * Application can register a callback function which will be called if there is change in ise state,language,mode etc.
1115     * To use this API application should include Ecore_IMF.h header file.
1116     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
1117     * @param ctx context used to map real loaded APIs.
1118     * @param pEventCallback the callback function to be called
1119     * @param data application-ISE specific data.
1120     * @return an integer unique to callabck registered.
1121     * @ingroup Ecore_IMF_Context_IMControl_Group
1122     * @code
1123     * #include <Ecore_IMF.h>
1124     *
1125     * void _input_panel_event_callback(void *data, Ecore_IMF_Context *ctx, int value)
1126     * {
1127     *     if(value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
1128     *         // ISE state has changed to ECORE_IMF_INPUT_PANEL_STATE_SHOW status
1129     *     } else if(value == ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
1130     *         // ISE state has changed to ECORE_IMF_INPUT_PANEL_STATE_HIDE status
1131     *     }
1132     *     printf("value: %d\n", value);
1133     * }
1134     *
1135     * static void create_entry(struct appdata *ad)
1136     * {
1137     *     Evas_Object *en;
1138     *     en = elm_entry_add(ad->layout_main);
1139     *     elm_layout_content_set(ad->layout_main, "entry", en);
1140     *
1141     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
1142     *
1143     *     if (imf_context)
1144     *     {
1145     *         ecore_imf_context_input_panel_event_callback_add (imf_context, ECORE_IMF_INPUT_PANEL_STATE_EVENT, _input_panel_event_callback, data);
1146     *     }
1147     * }
1148     * @endcode
1149     * In order to deregister the callback function registered application should follow the below step.
1150     * ecore_imf_context_input_panel_event_callback_del (imf_context, ECORE_IMF_INPUT_PANEL_STATE_EVENT, _ise_event_callback);
1151     */
1152    EAPI void ecore_imf_context_input_panel_event_callback_add (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Event type, void (*pEventCallbackFunc) (void *data, Ecore_IMF_Context *ctx, int value), const void *data);
1153
1154    EAPI void ecore_imf_context_input_panel_event_callback_del (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Event type, void (*pEventCallbackFunc) (void *data, Ecore_IMF_Context *ctx, int value));
1155
1156    /**
1157     * Set the key to be disabled.
1158     * To use this API application should include Ecore_IMF.h header file.
1159     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
1160     * Since the second parameter of this API requires a layout index, so before using this API application has to set a specific layout and that layout index
1161     * should be passed in the 2nd argument of this API(see sample code).
1162     * @param ctx context used to map real loaded APIs
1163     * @param layout_index index of layout page to be set
1164     * @param key_index index of key to be set
1165     * @param disabled The state
1166     * @ingroup Ecore_IMF_Context_IMControl_Group
1167     * @code
1168     * #include <Ecore_IMF.h>
1169     *
1170     * static void create_entry(struct appdata *ad)
1171     * {
1172     *     Evas_Object *en;
1173     *     en = elm_entry_add(ad->layout_main);
1174     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
1175     *
1176     *     if (imf_context)
1177     *     {
1178     *         ecore_imf_context_input_panel_key_disabled_set (imf_context, layout, ECORE_IMF_INPUT_PANEL_KEY_SPACE, EINA_TRUE);
1179     *     }
1180     * }
1181     * @endcode
1182     */
1183    EAPI void ecore_imf_context_input_panel_key_disabled_set  (Ecore_IMF_Context *ctx, int layout_index, int key_index, Eina_Bool disabled);
1184
1185    EAPI Eina_List *ecore_imf_context_input_panel_key_disabled_list_get  (Ecore_IMF_Context *ctx);
1186
1187    /**
1188     * Move the soft keyboard to the new position.
1189     * To use this API application should include Ecore_IMF.h header file.
1190     * The first parameter i.e Ecore_IMF_Context *ctx is used to map the ecore_imf API into real implemented API which is inside ISF.
1191     * Since the second parameter of this API requires a layout index, so before using this API application has to set a specific layout and that layout index
1192     * should be passed in the 2nd argument of this API(see sample code).
1193     * @param ctx context used to map real loaded APIs
1194     * @param x X position to move the virtual keyboard to
1195     * @param y Y position to move the virtual keyboard to
1196     * @ingroup Ecore_IMF_Context_IMControl_Group
1197     * @code
1198     * #include <Ecore_IMF.h>
1199     *
1200     * static void create_entry(struct appdata *ad)
1201     * {
1202     *     Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(obj);
1203     *
1204     *     if (imf_context)
1205     *     {
1206     *         ecore_imf_context_input_panel_move (imf_context, 0, 400);
1207     *     }
1208     * }
1209     * @endcode
1210     */
1211    EAPI void ecore_imf_context_input_panel_move  (Ecore_IMF_Context *ctx, int x, int y);
1212
1213    EAPI void ecore_imf_context_input_panel_caps_mode_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Caps_Mode mode);
1214
1215    /* The following entry points must be exported by each input method module
1216     */
1217
1218    /*
1219     * int                imf_module_init   (const Ecore_IMF_Context_Info **info);
1220     * void               imf_module_exit   (void);
1221     * Ecore_IMF_Context *imf_module_create (void);
1222     */
1223
1224 #ifdef __cplusplus
1225 }
1226 #endif
1227
1228 #endif
1229
1230 /* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/