src/lib/ecore_imf/ecore_imf_context.c

   1 #ifdef HAVE_CONFIG_H
   2 # include <config.h>
   3 #endif
   4
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <locale.h>
   8
   9 #include <Ecore.h>
  10 #include <ecore_private.h>
  11
  12 #include "Ecore_IMF.h"
  13 #include "ecore_imf_private.h"
  14
  15 /**
  16  * @defgroup Ecore_IMF_Context_Group Ecore Input Method Context Functions
  17  *
  18  * Functions that operate on Ecore Input Method Context objects.
  19  */
  20
  21 /**
  22  * Get the list of the available Input Method Context ids.
  23  *
  24  * Note that the caller is responsible for freeing the Eina_List
  25  * when finished with it. There is no need to finish the list strings.
  26  *
  27  * @return Return an Eina_List of strings;
  28  *         on failure it returns NULL.
  29  * @ingroup Ecore_IMF_Context_Group
  30  */
  31 EAPI Eina_List *
  32 ecore_imf_context_available_ids_get(void)
  33 {
  34    return ecore_imf_module_context_ids_get();
  35 }
  36
  37 EAPI Eina_List *
  38 ecore_imf_context_available_ids_by_canvas_type_get(const char *canvas_type)
  39 {
  40    return ecore_imf_module_context_ids_by_canvas_type_get(canvas_type);
  41 }
  42
  43 /*
  44  * Match @locale against @against.
  45  *
  46  * 'en_US' against 'en_US'       => 4
  47  * 'en_US' against 'en'          => 3
  48  * 'en', 'en_UK' against 'en_US' => 2
  49  *  all locales, against '*'     => 1
  50  */
  51 static int
  52 _ecore_imf_context_match_locale(const char *locale, const char *against, int against_len)
  53 {
  54    if (strcmp(against, "*") == 0)
  55      return 1;
  56
  57    if (strcasecmp(locale, against) == 0)
  58      return 4;
  59
  60    if (strncasecmp(locale, against, 2) == 0)
  61      return (against_len == 2) ? 3 : 2;
  62
  63    return 0;
  64 }
  65
  66 /**
  67  * Get the id of the default Input Method Context.
  68  * The id may to used to create a new instance of an Input Method
  69  * Context object.
  70  *
  71  * @return Return a string containing the id of the default Input
  72  *         Method Context; on failure it returns NULL.
  73  * @ingroup Ecore_IMF_Context_Group
  74  */
  75 EAPI const char *
  76 ecore_imf_context_default_id_get(void)
  77 {
  78    return ecore_imf_context_default_id_by_canvas_type_get(NULL);
  79 }
  80
  81 EAPI const char *
  82 ecore_imf_context_default_id_by_canvas_type_get(const char *canvas_type)
  83 {
  84    const char *id;
  85    Eina_List *modules;
  86    Ecore_IMF_Module *module;
  87    char *locale;
  88    char *tmp;
  89    int best_goodness = 0;
  90
  91    id = getenv("ECORE_IMF_MODULE");
  92    if (id)
  93      {
  94         if (strcmp(id, "none") == 0) return NULL;
  95         if (ecore_imf_module_get(id)) return id;
  96      }
  97
  98    modules = ecore_imf_module_available_get();
  99    if (!modules) return NULL;
 100
 101    locale = setlocale(LC_CTYPE, NULL);
 102    if (!locale) return NULL;
 103
 104    locale = strdup(locale);
 105
 106    tmp = strchr(locale, '.');
 107    if (tmp) *tmp = '\0';
 108    tmp = strchr(locale, '@');
 109    if (tmp) *tmp = '\0';
 110
 111    id = NULL;
 112
 113    EINA_LIST_FREE(modules, module)
 114      {
 115         if (canvas_type &&
 116             strcmp(module->info->canvas_type, canvas_type) == 0)
 117           continue;
 118
 119         const char *p = module->info->default_locales;
 120         while (p)
 121           {
 122              const char *q = strchr(p, ':');
 123              int goodness = _ecore_imf_context_match_locale(locale, p, q ? (size_t)(q - p) : strlen (p));
 124
 125              if (goodness > best_goodness)
 126                {
 127                   id = module->info->id;
 128                   best_goodness = goodness;
 129                }
 130
 131              p = q ? q + 1 : NULL;
 132           }
 133      }
 134
 135    free(locale);
 136    return id;
 137 }
 138
 139 /**
 140  * Retrieve the info for the Input Method Context with @p id.
 141  *
 142  * @param id The Input Method Context id to query for.
 143  * @return Return a #Ecore_IMF_Context_Info for the Input Method Context with @p id;
 144  *         on failure it returns NULL.
 145  * @ingroup Ecore_IMF_Context_Group
 146  *
 147  * Example
 148  * @code
 149  *
 150  * const char *ctx_id;
 151  * const Ecore_IMF_Context_Info *ctx_info;
 152  * Ecore_IMF_Context *imf_context;
 153  * ctx_id = ecore_imf_context_default_id_get();
 154  * if (ctx_id)
 155  *   {
 156  *      ctx_info = ecore_imf_context_info_by_id_get(ctx_id);
 157  *      if (!ctx_info->canvas_type ||
 158  *          strcmp(ctx_info->canvas_type, "evas") == 0)
 159  *        {
 160  *           imf_context = ecore_imf_context_add(ctx_id);
 161  *        }
 162  *      else
 163  *        {
 164  *           ctx_id = ecore_imf_context_default_id_by_canvas_type_get("evas");
 165  *           if (ctx_id)
 166  *             {
 167  *                imf_context = ecore_imf_context_add(ctx_id);
 168  *             }
 169  *        }
 170  *   }
 171  * @endcode
 172  */
 173 EAPI const Ecore_IMF_Context_Info *
 174 ecore_imf_context_info_by_id_get(const char *id)
 175 {
 176    Ecore_IMF_Module *module;
 177
 178    if (!id) return NULL;
 179    module = ecore_imf_module_get(id);
 180    if (!module) return NULL;
 181    return module->info;
 182 }
 183
 184 /**
 185  * Create a new Input Method Context defined by the given id.
 186  *
 187  * @param id The Input Method Context id.
 188  * @return A newly allocated Input Method Context;
 189  *         on failure it returns NULL.
 190  * @ingroup Ecore_IMF_Context_Group
 191  */
 192 EAPI Ecore_IMF_Context *
 193 ecore_imf_context_add(const char *id)
 194 {
 195    Ecore_IMF_Context *ctx;
 196
 197    if (!id) return NULL;
 198    ctx = ecore_imf_module_context_create(id);
 199    if (!ctx || !ctx->klass) return NULL;
 200    if (ctx->klass->add) ctx->klass->add(ctx);
 201    /* default use_preedit is EINA_TRUE, so let's make sure it's
 202     * set on the immodule */
 203    ecore_imf_context_use_preedit_set(ctx, EINA_TRUE);
 204
 205    /* default prediction is EINA_TRUE, so let's make sure it's
 206     * set on the immodule */
 207    ecore_imf_context_prediction_allow_set(ctx, EINA_TRUE);
 208
 209    /* default autocapital type is SENTENCE type, so let's make sure it's
 210     * set on the immodule */
 211    ecore_imf_context_autocapital_type_set(ctx, ECORE_IMF_AUTOCAPITAL_TYPE_SENTENCE);
 212
 213    /* default input panel enabled status is EINA_TRUE, so let's make sure it's
 214     * set on the immodule */
 215    ecore_imf_context_input_panel_enabled_set(ctx, EINA_TRUE);
 216
 217    /* default input panel layout type is NORMAL type, so let's make sure it's
 218     * set on the immodule */
 219    ecore_imf_context_input_panel_layout_set(ctx, ECORE_IMF_INPUT_PANEL_LAYOUT_NORMAL);
 220
 221    /* default input_mode is ECORE_IMF_INPUT_MODE_FULL, so let's make sure it's
 222     * set on the immodule */
 223    ecore_imf_context_input_mode_set(ctx, ECORE_IMF_INPUT_MODE_FULL);
 224    return ctx;
 225 }
 226
 227 /**
 228  * Retrieve the info for the given Input Method Context.
 229  *
 230  * @param ctx An #Ecore_IMF_Context.
 231  * @return Return a #Ecore_IMF_Context_Info for the given Input Method Context;
 232  *         on failure it returns NULL.
 233  * @ingroup Ecore_IMF_Context_Group
 234  */
 235 EAPI const Ecore_IMF_Context_Info *
 236 ecore_imf_context_info_get(Ecore_IMF_Context *ctx)
 237 {
 238    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 239      {
 240         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 241                          "ecore_imf_context_info_get");
 242         return NULL;
 243      }
 244    return ctx->module->info;
 245 }
 246
 247 /**
 248  * Delete the given Input Method Context and free its memory.
 249  *
 250  * @param ctx An #Ecore_IMF_Context.
 251  * @ingroup Ecore_IMF_Context_Group
 252  */
 253 EAPI void
 254 ecore_imf_context_del(Ecore_IMF_Context *ctx)
 255 {
 256    Ecore_IMF_Func_Node *fn;
 257
 258    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 259      {
 260         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 261                          "ecore_imf_context_del");
 262         return;
 263      }
 264    if (ctx->klass->del) ctx->klass->del(ctx);
 265
 266    if (ctx->callbacks)
 267      {
 268         EINA_LIST_FREE(ctx->callbacks, fn)
 269            free(fn);
 270      }
 271
 272    ECORE_MAGIC_SET(ctx, ECORE_MAGIC_NONE);
 273    free(ctx);
 274 }
 275
 276 /**
 277  * Set the client window for the Input Method Context; this is the
 278  * Ecore_X_Window when using X11, Ecore_Win32_Window when using Win32, etc.
 279  * This window is used in order to correctly position status windows, and may
 280  * also be used for purposes internal to the Input Method Context.
 281  *
 282  * @param ctx An #Ecore_IMF_Context.
 283  * @param window The client window. This may be NULL to indicate
 284  *               that the previous client window no longer exists.
 285  * @ingroup Ecore_IMF_Context_Group
 286  */
 287 EAPI void
 288 ecore_imf_context_client_window_set(Ecore_IMF_Context *ctx, void *window)
 289 {
 290    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 291      {
 292         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 293                          "ecore_imf_context_client_window_set");
 294         return;
 295      }
 296    if (ctx->klass->client_window_set) ctx->klass->client_window_set(ctx, window);
 297    ctx->window = window;
 298 }
 299
 300 /**
 301  * Get the client window of the Input Method Context
 302  *
 303  * See @ref ecore_imf_context_client_window_set for more details.
 304  *
 305  * @param ctx An #Ecore_IMF_Context.
 306  * @return Return the client window.
 307  * @ingroup Ecore_IMF_Context_Group
 308  * @since 1.1.0
 309  */
 310 EAPI void *
 311 ecore_imf_context_client_window_get(Ecore_IMF_Context *ctx)
 312 {
 313    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 314      {
 315         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 316                          "ecore_imf_context_client_window_get");
 317         return NULL;
 318      }
 319    return ctx->window;
 320 }
 321
 322 /**
 323  * Set the client canvas for the Input Method Context; this is the
 324  * canvas in which the input appears.
 325  * The canvas type can be determined by using the context canvas type.
 326  * Actually only canvas with type "evas" (Evas *) is supported.
 327  * This canvas may be used in order to correctly position status windows, and may
 328  * also be used for purposes internal to the Input Method Context.
 329  *
 330  * @param ctx An #Ecore_IMF_Context.
 331  * @param canvas The client canvas. This may be NULL to indicate
 332  *               that the previous client canvas no longer exists.
 333  * @ingroup Ecore_IMF_Context_Group
 334  */
 335 EAPI void
 336 ecore_imf_context_client_canvas_set(Ecore_IMF_Context *ctx, void *canvas)
 337 {
 338    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 339      {
 340         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 341                          "ecore_imf_context_client_canvas_set");
 342         return;
 343      }
 344    if (ctx->klass->client_canvas_set) ctx->klass->client_canvas_set(ctx, canvas);
 345    ctx->client_canvas = canvas;
 346 }
 347
 348 /**
 349  * Get the client canvas of the Input Method Context.
 350  *
 351  * See @ref ecore_imf_context_client_canvas_set for more details.
 352  *
 353  * @param ctx An #Ecore_IMF_Context.
 354  * @return Return the client canvas.
 355  * @ingroup Ecore_IMF_Context_Group
 356  * @since 1.1.0
 357  */
 358 EAPI void *
 359 ecore_imf_context_client_canvas_get(Ecore_IMF_Context *ctx)
 360 {
 361    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 362      {
 363         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 364                          "ecore_imf_context_client_canvas_get");
 365         return NULL;
 366      }
 367    return ctx->client_canvas;
 368 }
 369
 370 /**
 371  * Ask the Input Method Context to show itself.
 372  *
 373  * @param ctx An #Ecore_IMF_Context.
 374  * @ingroup Ecore_IMF_Context_Group
 375  */
 376 EAPI void
 377 ecore_imf_context_show(Ecore_IMF_Context *ctx)
 378 {
 379    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 380      {
 381         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 382                          "ecore_imf_context_show");
 383         return;
 384      }
 385    if (ctx->klass->show) ctx->klass->show(ctx);
 386 }
 387
 388 /**
 389  * Ask the Input Method Context to hide itself.
 390  *
 391  * @param ctx An #Ecore_IMF_Context.
 392  * @ingroup Ecore_IMF_Context_Group
 393  */
 394 EAPI void
 395 ecore_imf_context_hide(Ecore_IMF_Context *ctx)
 396 {
 397    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 398      {
 399         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 400                          "ecore_imf_context_hide");
 401         return;
 402      }
 403    if (ctx->klass->hide) ctx->klass->hide(ctx);
 404 }
 405
 406 /**
 407  * Retrieve the current preedit string and cursor position
 408  * for the Input Method Context.
 409  *
 410  * @param ctx An #Ecore_IMF_Context.
 411  * @param str Location to store the retrieved string. The
 412  *            string retrieved must be freed with free().
 413  * @param cursor_pos Location to store position of cursor (in characters)
 414  *                   within the preedit string.
 415  * @ingroup Ecore_IMF_Context_Group
 416  */
 417 EAPI void
 418 ecore_imf_context_preedit_string_get(Ecore_IMF_Context *ctx, char **str, int *cursor_pos)
 419 {
 420    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 421      {
 422         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 423                          "ecore_imf_context_preedit_string_get");
 424         return;
 425      }
 426    if (ctx->klass->preedit_string_get)
 427      ctx->klass->preedit_string_get(ctx, str, cursor_pos);
 428    else
 429      {
 430         if (str) *str = strdup("");
 431         if (cursor_pos) *cursor_pos = 0;
 432      }
 433 }
 434
 435 /**
 436  * Retrieve the current preedit string, atrributes and
 437  * cursor position for the Input Method Context.
 438  *
 439  * @param ctx An #Ecore_IMF_Context.
 440  * @param str Location to store the retrieved string. The
 441  *            string retrieved must be freed with free().
 442  * @param attrs an Eina_List of attributes
 443  * @param cursor_pos Location to store position of cursor (in characters)
 444  *                   within the preedit string.
 445  * @ingroup Ecore_IMF_Context_Group
 446  *
 447  * Example
 448  * @code
 449  * char *preedit_string;
 450  * int cursor_pos;
 451  * Eina_List *attrs = NULL, *l = NULL;
 452  * Ecore_IMF_Preedit_Attr *attr;
 453  *
 454  * ecore_imf_context_preedit_string_with_attributes_get(imf_context,
 455  *                                                      &preedit_string,
 456  *                                                      &attrs, &cursor_pos);
 457  * if (!preedit_string) return;
 458  *
 459  *  if (strlen(preedit_string) > 0)
 460  *    {
 461  *       if (attrs)
 462  *         {
 463  *            EINA_LIST_FOREACH(attrs, l, attr)
 464  *              {
 465  *                 if (attr->preedit_type == ECORE_IMF_PREEDIT_TYPE_SUB1)
 466  *                   {
 467  *                      // Something to do
 468  *                   }
 469  *                 else if (attr->preedit_type == ECORE_IMF_PREEDIT_TYPE_SUB2)
 470  *                   {
 471  *                      // Something to do
 472  *                   }
 473  *                 else if (attr->preedit_type == ECORE_IMF_PREEDIT_TYPE_SUB3)
 474  *                   {
 475  *                      // Something to do
 476  *                   }
 477  *              }
 478  *         }
 479  *    }
 480  *
 481  * // delete attribute list
 482  * if (attrs)
 483  *   {
 484  *      EINA_LIST_FREE(attrs, attr) free(attr);
 485  *   }
 486  *
 487  * free(preedit_string);
 488  * @endcode
 489  * @since 1.1.0
 490  */
 491 EAPI void
 492 ecore_imf_context_preedit_string_with_attributes_get(Ecore_IMF_Context *ctx, char **str, Eina_List **attrs, int *cursor_pos)
 493 {
 494    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 495      {
 496         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 497                          "ecore_imf_context_preedit_string_with_attributes_get");
 498         return;
 499      }
 500    if (ctx->klass->preedit_string_with_attributes_get)
 501      ctx->klass->preedit_string_with_attributes_get(ctx, str, attrs, cursor_pos);
 502    else
 503      {
 504         if (str) *str = strdup("");
 505         if (attrs) *attrs = NULL;
 506         if (cursor_pos) *cursor_pos = 0;
 507      }
 508 }
 509
 510 /**
 511  * Notify the Input Method Context that the widget to which its
 512  * correspond has gained focus.
 513  *
 514  * @param ctx An #Ecore_IMF_Context.
 515  * @ingroup Ecore_IMF_Context_Group
 516  *
 517  * Example
 518  * @code
 519  * static void
 520  * _focus_in_cb(void *data, Evas_Object *o, const char *emission, const char *source)
 521  * {
 522  *    ecore_imf_context_reset(imf_context);
 523  *    ecore_imf_context_focus_in(imf_context);
 524  * }
 525  *
 526  * evas_object_event_callback_add(obj, EVAS_CALLBACK_FOCUS_IN, _focus_in_cb, ed);
 527  * @endcode
 528  */
 529 EAPI void
 530 ecore_imf_context_focus_in(Ecore_IMF_Context *ctx)
 531 {
 532    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 533      {
 534         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 535                          "ecore_imf_context_focus_in");
 536         return;
 537      }
 538    if (ctx->klass->focus_in) ctx->klass->focus_in(ctx);
 539 }
 540
 541 /**
 542  * Notify the Input Method Context that the widget to which its
 543  * correspond has lost focus.
 544  *
 545  * @param ctx An #Ecore_IMF_Context.
 546  * @ingroup Ecore_IMF_Context_Group
 547  *
 548  * Example
 549  * @code
 550  * static void
 551  * _focus_out_cb(void *data, Evas_Object *o, const char *emission, const char *source)
 552  * {
 553  *    ecore_imf_context_reset(imf_context);
 554  *    ecore_imf_context_focus_out(imf_context);
 555  * }
 556  *
 557  * evas_object_event_callback_add(obj, EVAS_CALLBACK_FOCUS_OUT, _focus_out_cb, ed);
 558  * @endcode
 559  */
 560 EAPI void
 561 ecore_imf_context_focus_out(Ecore_IMF_Context *ctx)
 562 {
 563    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 564      {
 565         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 566                          "ecore_imf_context_focus_out");
 567         return;
 568      }
 569    if (ctx->klass->focus_out) ctx->klass->focus_out(ctx);
 570 }
 571
 572 /**
 573  * Notify the Input Method Context that a change such as a
 574  * change in cursor position has been made. This will typically
 575  * cause the Input Method Context to clear the preedit state.
 576  *
 577  * @param ctx An #Ecore_IMF_Context.
 578  * @ingroup Ecore_IMF_Context_Group
 579  *
 580  * Example
 581  * @code
 582  * static void
 583  * _focus_out_cb(void *data, Evas_Object *o, const char *emission, const char *source)
 584  * {
 585  *    ecore_imf_context_reset(imf_context);
 586  *    ecore_imf_context_focus_out(imf_context);
 587  * }
 588  *
 589  * evas_object_event_callback_add(obj, EVAS_CALLBACK_FOCUS_OUT, _focus_out_cb, ed);
 590  * @endcode
 591  */
 592 EAPI void
 593 ecore_imf_context_reset(Ecore_IMF_Context *ctx)
 594 {
 595    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 596      {
 597         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 598                          "ecore_imf_context_reset");
 599         return;
 600      }
 601    if (ctx->klass->reset) ctx->klass->reset(ctx);
 602 }
 603
 604 /**
 605  * Notify the Input Method Context that a change in the cursor
 606  * position has been made.
 607  *
 608  * @param ctx An #Ecore_IMF_Context.
 609  * @param cursor_pos New cursor position in characters.
 610  * @ingroup Ecore_IMF_Context_Group
 611  */
 612 EAPI void
 613 ecore_imf_context_cursor_position_set(Ecore_IMF_Context *ctx, int cursor_pos)
 614 {
 615    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 616      {
 617         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 618                          "ecore_imf_context_cursor_position_set");
 619         return;
 620      }
 621    if (ctx->klass->cursor_position_set) ctx->klass->cursor_position_set(ctx, cursor_pos);
 622 }
 623
 624 /**
 625  * Notify the Input Method Context that a change in the cursor
 626  * location has been made. The location is relative to the canvas.
 627  * The cursor location can be used to determine the position of
 628  * candidate word window in the immodule.
 629  *
 630  * @param ctx An #Ecore_IMF_Context.
 631  * @param x cursor x position.
 632  * @param y cursor y position.
 633  * @param w cursor width.
 634  * @param h cursor height.
 635  * @ingroup Ecore_IMF_Context_Group
 636  * @since 1.1.0
 637  */
 638 EAPI void
 639 ecore_imf_context_cursor_location_set(Ecore_IMF_Context *ctx, int x, int y, int w, int h)
 640 {
 641    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 642      {
 643         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 644                          "ecore_imf_context_cursor_location_set");
 645         return;
 646      }
 647    if (ctx->klass->cursor_location_set) ctx->klass->cursor_location_set(ctx, x, y, w, h);
 648 }
 649
 650 /**
 651  * Set whether the IM context should use the preedit string
 652  * to display feedback. If @c use_preedit is EINA_FALSE (default
 653  * is EINA_TRUE), then the IM context may use some other method to display
 654  * feedback, such as displaying it in a child of the root window.
 655  *
 656  * @param ctx An #Ecore_IMF_Context.
 657  * @param use_preedit Whether the IM context should use the preedit string.
 658  * @ingroup Ecore_IMF_Context_Group
 659  */
 660 EAPI void
 661 ecore_imf_context_use_preedit_set(Ecore_IMF_Context *ctx, Eina_Bool use_preedit)
 662 {
 663    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 664      {
 665         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 666                          "ecore_imf_context_use_preedit_set");
 667         return;
 668      }
 669    if (ctx->klass->use_preedit_set) ctx->klass->use_preedit_set(ctx, use_preedit);
 670 }
 671
 672 /**
 673  * Set whether the IM context should allow to use the text prediction.
 674  * If @c prediction is EINA_FALSE (default is EINA_TRUE), then the IM context will not display the text prediction window.
 675  *
 676  * @param ctx An #Ecore_IMF_Context.
 677  * @param prediction Whether the IM context should allow to use the text prediction.
 678  * @ingroup Ecore_IMF_Context_Group
 679  * @since 1.1.0
 680  */
 681 EAPI void
 682 ecore_imf_context_prediction_allow_set(Ecore_IMF_Context *ctx, Eina_Bool prediction)
 683 {
 684    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 685      {
 686         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 687                          "ecore_imf_context_prediction_allow_set");
 688         return;
 689      }
 690
 691    ctx->allow_prediction = prediction;
 692
 693    if (ctx->klass->prediction_allow_set)
 694      ctx->klass->prediction_allow_set(ctx, prediction);
 695 }
 696
 697 /**
 698  * Get whether the IM context should allow to use the text prediction.
 699  *
 700  * @param ctx An #Ecore_IMF_Context.
 701  * @return EINA_TRUE if it allows to use the text prediction, otherwise EINA_FALSE.
 702  * @ingroup Ecore_IMF_Context_Group
 703  * @since 1.1.0
 704  */
 705 EAPI Eina_Bool
 706 ecore_imf_context_prediction_allow_get(Ecore_IMF_Context *ctx)
 707 {
 708    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 709      {
 710         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 711                          "ecore_imf_context_prediction_allow_get");
 712         return EINA_FALSE;
 713      }
 714
 715    return ctx->allow_prediction;
 716 }
 717
 718 /**
 719  * Set the autocapitalization type on the immodule.
 720  *
 721  * @param ctx An #Ecore_IMF_Context.
 722  * @param autocapital_type the autocapitalization type.
 723  * @ingroup Ecore_IMF_Context_Group
 724  * @since 1.1.0
 725  */
 726 EAPI void
 727 ecore_imf_context_autocapital_type_set(Ecore_IMF_Context *ctx, Ecore_IMF_Autocapital_Type autocapital_type)
 728 {
 729    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 730      {
 731         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 732                          "ecore_imf_context_autocapital_type_set");
 733         return;
 734      }
 735
 736    ctx->autocapital_type = autocapital_type;
 737
 738    if (ctx->klass->autocapital_type_set) ctx->klass->autocapital_type_set(ctx, autocapital_type);
 739 }
 740
 741 /**
 742  * Get the autocapitalization type.
 743  *
 744  * @param ctx An #Ecore_IMF_Context.
 745  * @return The autocapital type being used by @p ctx.
 746  * @ingroup Ecore_IMF_Context_Group
 747  * @since 1.1.0
 748  */
 749 EAPI Ecore_IMF_Autocapital_Type
 750 ecore_imf_context_autocapital_type_get(Ecore_IMF_Context *ctx)
 751 {
 752    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 753      {
 754         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 755                          "ecore_imf_context_autocapital_allow_get");
 756         return ECORE_IMF_AUTOCAPITAL_TYPE_NONE;
 757      }
 758
 759    return ctx->autocapital_type;
 760 }
 761
 762 /**
 763  * Set the callback to be used on get_surrounding request.
 764  *
 765  * This callback will be called when the Input Method Context
 766  * module requests the surrounding context.
 767  *
 768  * @param ctx An #Ecore_IMF_Context.
 769  * @param func The callback to be called.
 770  * @param data The data pointer to be passed to @p func
 771  * @ingroup Ecore_IMF_Context_Group
 772  */
 773 EAPI void
 774 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)
 775 {
 776    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 777      {
 778         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 779                          "ecore_imf_context_retrieve_surrounding_callback_set");
 780         return;
 781      }
 782
 783    ctx->retrieve_surrounding_func = func;
 784    ctx->retrieve_surrounding_data = (void *) data;
 785 }
 786
 787 /**
 788  * Set the input mode used by the Ecore Input Context.
 789  *
 790  * The input mode can be one of the input modes defined in
 791  * #Ecore_IMF_Input_Mode. The default input mode is
 792  * ECORE_IMF_INPUT_MODE_FULL.
 793  *
 794  * @param ctx An #Ecore_IMF_Context.
 795  * @param input_mode The input mode to be used by @p ctx.
 796  * @ingroup Ecore_IMF_Context_Group
 797  */
 798 EAPI void
 799 ecore_imf_context_input_mode_set(Ecore_IMF_Context *ctx, Ecore_IMF_Input_Mode input_mode)
 800 {
 801    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 802      {
 803         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 804                          "ecore_imf_context_input_mode_set");
 805         return;
 806      }
 807    if (ctx->klass->input_mode_set) ctx->klass->input_mode_set(ctx, input_mode);
 808    ctx->input_mode = input_mode;
 809 }
 810
 811 /**
 812  * Get the input mode being used by the Ecore Input Context.
 813  *
 814  * See @ref ecore_imf_context_input_mode_set for more details.
 815  *
 816  * @param ctx An #Ecore_IMF_Context.
 817  * @return The input mode being used by @p ctx.
 818  * @ingroup Ecore_IMF_Context_Group
 819  */
 820 EAPI Ecore_IMF_Input_Mode
 821 ecore_imf_context_input_mode_get(Ecore_IMF_Context *ctx)
 822 {
 823    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 824      {
 825         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 826                          "ecore_imf_context_input_mode_set");
 827         return 0;
 828      }
 829    return ctx->input_mode;
 830 }
 831
 832 /**
 833  * Allow an Ecore Input Context to internally handle an event.
 834  * If this function returns EINA_TRUE, then no further processing
 835  * should be done for this event.
 836  *
 837  * Input methods must be able to accept all types of events (simply
 838  * returning EINA_FALSE if the event was not handled), but there is no
 839  * obligation of any events to be submitted to this function.
 840  *
 841  * @param ctx An #Ecore_IMF_Context.
 842  * @param type The type of event defined by #Ecore_IMF_Event_Type.
 843  * @param event The event itself.
 844  * @return EINA_TRUE if the event was handled; otherwise EINA_FALSE.
 845  * @ingroup Ecore_IMF_Context_Group
 846  *
 847  * Example
 848  * @code
 849  * static void
 850  * _key_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 851  * {
 852  *    Evas_Event_Key_Down *ev = event_info;
 853  *    if (!ev->keyname) return;
 854  *
 855  *    if (imf_context)
 856  *      {
 857  *         Ecore_IMF_Event_Key_Down ecore_ev;
 858  *         ecore_imf_evas_event_key_down_wrap(ev, &ecore_ev);
 859  *         if (ecore_imf_context_filter_event(imf_context,
 860  *                                            ECORE_IMF_EVENT_KEY_DOWN,
 861  *                                            (Ecore_IMF_Event *)&ecore_ev))
 862  *           return;
 863  *      }
 864  * }
 865  *
 866  * evas_object_event_callback_add(obj, EVAS_CALLBACK_KEY_DOWN, _key_down_cb, data);
 867  * @endcode
 868  */
 869 EAPI Eina_Bool
 870 ecore_imf_context_filter_event(Ecore_IMF_Context *ctx, Ecore_IMF_Event_Type type, Ecore_IMF_Event *event)
 871 {
 872    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 873      {
 874         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 875                          "ecore_imf_context_filter_event");
 876         return EINA_FALSE;
 877      }
 878    if (ctx->klass->filter_event) return ctx->klass->filter_event(ctx, type, event);
 879    return EINA_FALSE;
 880 }
 881
 882 /**
 883  * @defgroup Ecore_IMF_Context_Module_Group Ecore Input Method Context Module Functions
 884  *
 885  * Functions that should be used by Ecore Input Method Context modules.
 886  */
 887
 888 /**
 889  * Creates a new Input Method Context with klass specified by @p ctxc.
 890  *
 891  * This method should be used by modules implementing the Input
 892  * Method Context interface.
 893  *
 894  * @param ctxc An #Ecore_IMF_Context_Class.
 895  * @return A new #Ecore_IMF_Context; on failure it returns NULL.
 896  * @ingroup Ecore_IMF_Context_Module_Group
 897  */
 898 EAPI Ecore_IMF_Context *
 899 ecore_imf_context_new(const Ecore_IMF_Context_Class *ctxc)
 900 {
 901    Ecore_IMF_Context *ctx;
 902
 903    if (!ctxc) return NULL;
 904    ctx = calloc(1, sizeof(Ecore_IMF_Context));
 905    if (!ctx) return NULL;
 906    ECORE_MAGIC_SET(ctx, ECORE_MAGIC_CONTEXT);
 907    ctx->klass = ctxc;
 908    ctx->data = NULL;
 909    ctx->retrieve_surrounding_func = NULL;
 910    ctx->retrieve_surrounding_data = NULL;
 911    return ctx;
 912 }
 913
 914 /**
 915  * Set the Input Method Context specific data.
 916  *
 917  * Note that this method should be used by modules to set
 918  * the Input Method Context specific data and it's not meant to
 919  * be used by applications to store application specific data.
 920  *
 921  * @param ctx An #Ecore_IMF_Context.
 922  * @param data The Input Method Context specific data.
 923  * @return A new #Ecore_IMF_Context; on failure it returns NULL.
 924  * @ingroup Ecore_IMF_Context_Module_Group
 925  */
 926 EAPI void
 927 ecore_imf_context_data_set(Ecore_IMF_Context *ctx, void *data)
 928 {
 929    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 930      {
 931         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 932                          "ecore_imf_context_data_set");
 933         return;
 934      }
 935    ctx->data = data;
 936 }
 937
 938 /**
 939  * Get the Input Method Context specific data.
 940  *
 941  * See @ref ecore_imf_context_data_set for more details.
 942  *
 943  * @param ctx An #Ecore_IMF_Context.
 944  * @return The Input Method Context specific data.
 945  * @ingroup Ecore_IMF_Context_Module_Group
 946  */
 947 EAPI void *ecore_imf_context_data_get(Ecore_IMF_Context *ctx)
 948 {
 949    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 950      {
 951         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 952                          "ecore_imf_context_data_get");
 953         return NULL;
 954      }
 955    return ctx->data;
 956 }
 957
 958 /**
 959  * Retrieve context around insertion point.
 960  *
 961  * This function is implemented by calling the
 962  * Ecore_IMF_Context::retrieve_surrounding_func (
 963  * set using #ecore_imf_context_retrieve_surrounding_callback_set).
 964  *
 965  * There is no obligation for a widget to respond to the
 966  * ::retrieve_surrounding_func, so input methods must be prepared
 967  * to function without context.
 968  *
 969  * @param ctx An #Ecore_IMF_Context.
 970  * @param text Location to store a UTF-8 encoded string of text
 971  *             holding context around the insertion point.
 972  *             If the function returns EINA_TRUE, then you must free
 973  *             the result stored in this location with free().
 974  * @param cursor_pos Location to store the position in characters of
 975  *                   the insertion cursor within @p text.
 976  * @return EINA_TRUE if surrounding text was provided; otherwise EINA_FALSE.
 977  * @ingroup Ecore_IMF_Context_Module_Group
 978  */
 979 EAPI Eina_Bool
 980 ecore_imf_context_surrounding_get(Ecore_IMF_Context *ctx, char **text, int *cursor_pos)
 981 {
 982    int result = EINA_FALSE;
 983
 984    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
 985      {
 986         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
 987                          "ecore_imf_context_surrounding_get");
 988         return EINA_FALSE;
 989      }
 990
 991    if (ctx->retrieve_surrounding_func)
 992      {
 993         result = ctx->retrieve_surrounding_func(ctx->retrieve_surrounding_data, ctx, text, cursor_pos);
 994         if (!result)
 995           {
 996              if (text) *text = NULL;
 997              if (cursor_pos) *cursor_pos = 0;
 998           }
 999      }
1000    return result;
1001 }
1002
1003 static void
1004 _ecore_imf_event_free_preedit(void *data __UNUSED__, void *event)
1005 {
1006    free(event);
1007 }
1008
1009 /**
1010  * Adds ECORE_IMF_EVENT_PREEDIT_START to the event queue.
1011  *
1012  * ECORE_IMF_EVENT_PREEDIT_START should be added when a new preedit sequence starts.
1013  * It's asynchronous method to put event to the event queue.
1014  * ecore_imf_context_event_callback_call() can be used as synchronous method.
1015  *
1016  * @param ctx An #Ecore_IMF_Context.
1017  * @ingroup Ecore_IMF_Context_Module_Group
1018  */
1019 EAPI void
1020 ecore_imf_context_preedit_start_event_add(Ecore_IMF_Context *ctx)
1021 {
1022    Ecore_IMF_Event_Commit *ev;
1023
1024    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1025      {
1026         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1027                          "ecore_imf_context_preedit_start_event_add");
1028         return;
1029      }
1030
1031    ev = malloc(sizeof(Ecore_IMF_Event_Preedit_Start));
1032    ev->ctx = ctx;
1033    ecore_event_add(ECORE_IMF_EVENT_PREEDIT_START,
1034                    ev, _ecore_imf_event_free_preedit, NULL);
1035 }
1036
1037 /**
1038  * Adds ECORE_IMF_EVENT_PREEDIT_END to the event queue.
1039  *
1040  * ECORE_IMF_EVENT_PREEDIT_END should be added when a new preedit sequence has been completed or canceled.
1041  * It's asynchronous method to put event to the event queue.
1042  * ecore_imf_context_event_callback_call() can be used as synchronous method.
1043  *
1044  * @param ctx An #Ecore_IMF_Context.
1045  * @ingroup Ecore_IMF_Context_Module_Group
1046  */
1047 EAPI void
1048 ecore_imf_context_preedit_end_event_add(Ecore_IMF_Context *ctx)
1049 {
1050    Ecore_IMF_Event_Commit *ev;
1051
1052    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1053      {
1054         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1055                          "ecore_imf_context_preedit_end_event_add");
1056         return;
1057      }
1058
1059    ev = malloc(sizeof(Ecore_IMF_Event_Preedit_End));
1060    ev->ctx = ctx;
1061    ecore_event_add(ECORE_IMF_EVENT_PREEDIT_END,
1062                    ev, _ecore_imf_event_free_preedit, NULL);
1063 }
1064
1065 /**
1066  * Adds ECORE_IMF_EVENT_PREEDIT_CHANGED to the event queue.
1067  *
1068  * It's asynchronous method to put event to the event queue.
1069  * ecore_imf_context_event_callback_call() can be used as synchronous method.
1070  *
1071  * @param ctx An #Ecore_IMF_Context.
1072  * @ingroup Ecore_IMF_Context_Module_Group
1073  */
1074 EAPI void
1075 ecore_imf_context_preedit_changed_event_add(Ecore_IMF_Context *ctx)
1076 {
1077    Ecore_IMF_Event_Commit *ev;
1078
1079    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1080      {
1081         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1082                          "ecore_imf_context_preedit_changed_event_add");
1083         return;
1084      }
1085
1086    ev = malloc(sizeof(Ecore_IMF_Event_Preedit_Changed));
1087    ev->ctx = ctx;
1088    ecore_event_add(ECORE_IMF_EVENT_PREEDIT_CHANGED,
1089                    ev, _ecore_imf_event_free_preedit, NULL);
1090 }
1091
1092 static void
1093 _ecore_imf_event_free_commit(void *data __UNUSED__, void *event)
1094 {
1095    Ecore_IMF_Event_Commit *ev;
1096
1097    ev = event;
1098    if (ev->str) free(ev->str);
1099    free(ev);
1100 }
1101
1102 /**
1103  * Adds ECORE_IMF_EVENT_COMMIT to the event queue.
1104  *
1105  * It's asynchronous method to put event to the event queue.
1106  * ecore_imf_context_event_callback_call() can be used as synchronous method.
1107  *
1108  * @param ctx An #Ecore_IMF_Context.
1109  * @param str The committed string.
1110  * @ingroup Ecore_IMF_Context_Module_Group
1111  */
1112 EAPI void
1113 ecore_imf_context_commit_event_add(Ecore_IMF_Context *ctx, const char *str)
1114 {
1115    Ecore_IMF_Event_Commit *ev;
1116
1117    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1118      {
1119         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1120                          "ecore_imf_context_commit_event_add");
1121         return;
1122      }
1123
1124    ev = malloc(sizeof(Ecore_IMF_Event_Commit));
1125    ev->ctx = ctx;
1126    ev->str = str ? strdup(str) : NULL;
1127    ecore_event_add(ECORE_IMF_EVENT_COMMIT,
1128                    ev, _ecore_imf_event_free_commit, NULL);
1129
1130 }
1131
1132 static void
1133 _ecore_imf_event_free_delete_surrounding(void *data __UNUSED__, void *event)
1134 {
1135    free(event);
1136 }
1137
1138 /**
1139  * Adds ECORE_IMF_EVENT_DELETE_SURROUNDING to the event queue.
1140  *
1141  * Asks the widget that the input context is attached to to delete characters around the cursor position
1142  * by adding the ECORE_IMF_EVENT_DELETE_SURROUNDING to the event queue.
1143  * Note that offset and n_chars are in characters not in bytes.
1144  *
1145  * It's asynchronous method to put ECORE_IMF_EVENT_DELETE_SURROUNDING event to the event queue.
1146  * ecore_imf_context_event_callback_call() can be used as synchronous method.
1147  *
1148  * @param ctx An #Ecore_IMF_Context.
1149  * @param offset The start offset of surrounding to be deleted.
1150  * @param n_chars The number of characters to be deleted.
1151  * @ingroup Ecore_IMF_Context_Module_Group
1152  */
1153 EAPI void
1154 ecore_imf_context_delete_surrounding_event_add(Ecore_IMF_Context *ctx, int offset, int n_chars)
1155 {
1156    Ecore_IMF_Event_Delete_Surrounding *ev;
1157
1158    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1159      {
1160         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1161                          "ecore_imf_context_delete_surrounding_event_add");
1162         return;
1163      }
1164
1165    ev = malloc(sizeof(Ecore_IMF_Event_Delete_Surrounding));
1166    ev->ctx = ctx;
1167    ev->offset = offset;
1168    ev->n_chars = n_chars;
1169    ecore_event_add(ECORE_IMF_EVENT_DELETE_SURROUNDING,
1170                    ev, _ecore_imf_event_free_delete_surrounding, NULL);
1171 }
1172
1173 /**
1174  * Add (register) a callback function to a given context event.
1175  *
1176  * This function adds a function callback to the context @p ctx when the
1177  * event of type @p type occurs on it. The function pointer is @p
1178  * func.
1179  *
1180  * The event type @p type to trigger the function may be one of
1181  * #ECORE_IMF_CALLBACK_PREEDIT_START, #ECORE_IMF_CALLBACK_PREEDIT_END,
1182  * #ECORE_IMF_CALLBACK_PREEDIT_CHANGED, #ECORE_IMF_CALLBACK_COMMIT and
1183  * #ECORE_IMF_CALLBACK_DELETE_SURROUNDING.
1184  *
1185  * @param ctx Ecore_IMF_Context to attach a callback to.
1186  * @param type The type of event that will trigger the callback
1187  * @param func The (callback) function to be called when the event is
1188  *        triggered
1189  * @param data The data pointer to be passed to @p func
1190  * @ingroup Ecore_IMF_Context_Group
1191  * @since 1.2.0
1192  *
1193  * Example
1194  * @code
1195  * static void
1196  * _imf_event_commit_cb(void *data, Ecore_IMF_Context *ctx, void *event_info)
1197  * {
1198  *    char *commit_str = event_info;
1199  *    // something to do
1200  * }
1201  *
1202  * ecore_imf_context_event_callback_add(en->imf_context, ECORE_IMF_CALLBACK_COMMIT, _imf_event_commit_cb, data);
1203  * @endcode
1204  */
1205 EAPI void
1206 ecore_imf_context_event_callback_add(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, Ecore_IMF_Event_Cb func, const void *data)
1207 {
1208    Ecore_IMF_Func_Node *fn = NULL;
1209
1210    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1211      {
1212         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1213                          "ecore_imf_context_event_callback_add");
1214         return;
1215      }
1216
1217    if (!func) return;
1218
1219    fn = calloc(1, sizeof (Ecore_IMF_Func_Node));
1220    if (!fn) return;
1221
1222    fn->func = func;
1223    fn->data = data;
1224    fn->type = type;
1225
1226    ctx->callbacks = eina_list_append(ctx->callbacks, fn);
1227 }
1228
1229 /**
1230  * Delete (unregister) a callback function registered to a given
1231  * context event.
1232  *
1233  * This function removes a function callback from the context @p ctx when the
1234  * event of type @p type occurs on it. The function pointer is @p
1235  * func.
1236  *
1237  * @see ecore_imf_context_event_callback_add() for more details
1238  *
1239  * @param ctx Ecore_IMF_Context to remove a callback from.
1240  * @param type The type of event that was trigerring the callback
1241  * @param func The (callback) function that was to be called when the event was triggered
1242  * @return the data pointer
1243  * @ingroup Ecore_IMF_Context_Group
1244  * @since 1.2.0
1245  */
1246 EAPI void *
1247 ecore_imf_context_event_callback_del(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, Ecore_IMF_Event_Cb func)
1248 {
1249    Eina_List *l = NULL;
1250    Eina_List *l_next = NULL;
1251    Ecore_IMF_Func_Node *fn = NULL;
1252
1253    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1254      {
1255         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1256                          "ecore_imf_context_event_callback_del");
1257         return NULL;
1258      }
1259
1260    if (!func) return NULL;
1261    if (!ctx->callbacks) return NULL;
1262
1263    EINA_LIST_FOREACH_SAFE(ctx->callbacks, l, l_next, fn)
1264      {
1265         if ((fn) && (fn->func == func) && (fn->type == type))
1266           {
1267              void *tmp = (void *)fn->data;
1268              free(fn);
1269              ctx->callbacks = eina_list_remove_list(ctx->callbacks, l);
1270              return tmp;
1271           }
1272      }
1273    return NULL;
1274 }
1275
1276 /**
1277  * Call a given callback on the context @p ctx.
1278  *
1279  * ecore_imf_context_preedit_start_event_add, ecore_imf_context_preedit_end_event_add,
1280  * ecore_imf_context_preedit_changed_event_add, ecore_imf_context_commit_event_add and
1281  * ecore_imf_context_delete_surrounding_event_add APIs are asynchronous
1282  * because those API adds each event to the event queue.
1283  *
1284  * This API provides the way to call each callback function immediately.
1285  *
1286  * @param ctx Ecore_IMF_Context.
1287  * @param type The type of event that will trigger the callback
1288  * @param event_info The pointer to event specific struct or information to
1289  *        pass to the callback functions registered on this event
1290  * @ingroup Ecore_IMF_Context_Module_Group
1291  * @since 1.2.0
1292  */
1293 EAPI void
1294 ecore_imf_context_event_callback_call(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, void *event_info)
1295 {
1296    Ecore_IMF_Func_Node *fn = NULL;
1297    Eina_List *l = NULL;
1298
1299    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1300      {
1301         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1302                          "ecore_imf_context_event_callback_call");
1303         return;
1304      }
1305
1306    EINA_LIST_FOREACH(ctx->callbacks, l, fn)
1307      {
1308         if ((fn) && (fn->type == type) && (fn->func))
1309           fn->func(fn->data, ctx, event_info);
1310      }
1311 }
1312
1313 /**
1314  * Ask the Input Method Context to show the control panel of using Input Method.
1315  *
1316  * @param ctx An #Ecore_IMF_Context.
1317  * @ingroup Ecore_IMF_Context_Group
1318  * @since 1.1.0
1319  */
1320 EAPI void
1321 ecore_imf_context_control_panel_show(Ecore_IMF_Context *ctx)
1322 {
1323    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1324      {
1325         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1326                          "ecore_imf_context_control_panel_show");
1327         return;
1328      }
1329
1330    if (ctx->klass->control_panel_show) ctx->klass->control_panel_show(ctx);
1331 }
1332
1333 /**
1334  * Ask the Input Method Context to hide the control panel of using Input Method.
1335  *
1336  * @param ctx An #Ecore_IMF_Context.
1337  * @ingroup Ecore_IMF_Context_Group
1338  * @since 1.1.0
1339  */
1340 EAPI void
1341 ecore_imf_context_control_panel_hide(Ecore_IMF_Context *ctx)
1342 {
1343    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1344      {
1345         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1346                          "ecore_imf_context_control_panel_hide");
1347         return;
1348      }
1349
1350    if (ctx->klass->control_panel_hide) ctx->klass->control_panel_hide(ctx);
1351 }
1352
1353 /**
1354  * Ask the Input Method Context to show the input panel (virtual keyboard).
1355  *
1356  * @param ctx An #Ecore_IMF_Context.
1357  * @ingroup Ecore_IMF_Context_Group
1358  * @since 1.1.0
1359  */
1360 EAPI void
1361 ecore_imf_context_input_panel_show(Ecore_IMF_Context *ctx)
1362 {
1363    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1364      {
1365         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1366                          "ecore_imf_context_input_panel_show");
1367         return;
1368      }
1369
1370    if (ctx->klass->show) ctx->klass->show(ctx);
1371 }
1372
1373 /**
1374  * Ask the Input Method Context to hide the input panel.
1375  *
1376  * @param ctx An #Ecore_IMF_Context.
1377  * @ingroup Ecore_IMF_Context_Group
1378  * @since 1.1.0
1379  */
1380 EAPI void
1381 ecore_imf_context_input_panel_hide(Ecore_IMF_Context *ctx)
1382 {
1383    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1384      {
1385         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1386                          "ecore_imf_context_input_panel_hide");
1387         return;
1388      }
1389
1390    if (ctx->klass->hide) ctx->klass->hide(ctx);
1391 }
1392
1393 /**
1394  * Set the layout of the input panel.
1395  *
1396  * @param ctx An #Ecore_IMF_Context.
1397  * @param layout see #Ecore_IMF_Input_Panel_Layout
1398  * @ingroup Ecore_IMF_Context_Group
1399  * @since 1.1.0
1400  */
1401 EAPI void
1402 ecore_imf_context_input_panel_layout_set(Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Layout layout)
1403 {
1404    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1405      {
1406         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1407                          "ecore_imf_context_input_panel_layout_set");
1408         return;
1409      }
1410
1411    if (ctx->klass->input_panel_layout_set)
1412      ctx->klass->input_panel_layout_set(ctx, layout);
1413
1414    ctx->input_panel_layout = layout;
1415 }
1416
1417 /**
1418  * Get the layout of the current active input panel.
1419  *
1420  * @param ctx An #Ecore_IMF_Context.
1421  * @return layout see #Ecore_IMF_Input_Panel_Layout
1422  * @ingroup Ecore_IMF_Context_Group
1423  * @since 1.1.0
1424  */
1425 EAPI Ecore_IMF_Input_Panel_Layout
1426 ecore_imf_context_input_panel_layout_get(Ecore_IMF_Context *ctx)
1427 {
1428    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1429      {
1430         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1431                          "ecore_imf_context_input_panel_layout_get");
1432         return ECORE_IMF_INPUT_PANEL_LAYOUT_INVALID;
1433      }
1434
1435    if (ctx->klass->input_panel_layout_get)
1436      return ctx->input_panel_layout;
1437    else
1438      return ECORE_IMF_INPUT_PANEL_LAYOUT_INVALID;
1439 }
1440
1441 /**
1442  * Set the language of the input panel.
1443  * This API can be used when you want to show the English keyboard.
1444  *
1445  * @param ctx An #Ecore_IMF_Context.
1446  * @param lang the language to be set to the input panel.
1447  * @ingroup Ecore_IMF_Context_Group
1448  * @since 1.1.0
1449  */
1450 EAPI void
1451 ecore_imf_context_input_panel_language_set(Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Lang lang)
1452 {
1453    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1454      {
1455         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1456                          "ecore_imf_context_input_panel_language_set");
1457         return;
1458      }
1459
1460    if (ctx->klass->input_panel_language_set) ctx->klass->input_panel_language_set(ctx, lang);
1461    ctx->input_panel_lang = lang;
1462 }
1463
1464 /**
1465  * Get the language of the input panel.
1466  *
1467  * See @ref ecore_imf_context_input_panel_language_set for more details.
1468  *
1469  * @param ctx An #Ecore_IMF_Context.
1470  * @return Ecore_IMF_Input_Panel_Lang
1471  * @ingroup Ecore_IMF_Context_Group
1472  * @since 1.1.0
1473  */
1474 EAPI Ecore_IMF_Input_Panel_Lang
1475 ecore_imf_context_input_panel_language_get(Ecore_IMF_Context *ctx)
1476 {
1477    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1478      {
1479         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1480                          "ecore_imf_context_input_panel_language_get");
1481         return ECORE_IMF_INPUT_PANEL_LANG_AUTOMATIC;
1482      }
1483
1484    return ctx->input_panel_lang;
1485 }
1486
1487 /**
1488  * Set whether the Input Method Context should request to show the input panel automatically
1489  * when the widget has focus.
1490  *
1491  * @param ctx An #Ecore_IMF_Context.
1492  * @param enabled If true, the input panel will be shown when the widget is clicked or has focus.
1493  * @ingroup Ecore_IMF_Context_Group
1494  * @since 1.1.0
1495  */
1496 EAPI void
1497 ecore_imf_context_input_panel_enabled_set(Ecore_IMF_Context *ctx,
1498                                            Eina_Bool enabled)
1499 {
1500    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1501      {
1502         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1503                          "ecore_imf_context_input_panel_enabled_set");
1504         return;
1505      }
1506
1507    ctx->input_panel_enabled = enabled;
1508 }
1509
1510 /**
1511  * Get whether the Input Method Context requests to show the input panel automatically.
1512  *
1513  * @param ctx An #Ecore_IMF_Context.
1514  * @return Return the attribute to show the input panel automatically
1515  * @ingroup Ecore_IMF_Context_Group
1516  * @since 1.1.0
1517  */
1518 EAPI Eina_Bool
1519 ecore_imf_context_input_panel_enabled_get(Ecore_IMF_Context *ctx)
1520 {
1521    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1522      {
1523         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1524                          "ecore_imf_context_input_panel_enabled_get");
1525         return EINA_FALSE;
1526      }
1527
1528    return ctx->input_panel_enabled;
1529 }
1530
1531 /**
1532  * Set the input panel-specific data to deliver to the input panel.
1533  * this API is used by applications to deliver specific data to the input panel.
1534  * the data format MUST be negotiated by both application and the input panel.
1535  * The size and format of data are defined by the input panel.
1536  *
1537  * @param ctx An #Ecore_IMF_Context.
1538  * @param data The specific data to be set to the input panel.
1539  * @param len the length of data, in bytes, to send to the input panel
1540  * @ingroup Ecore_IMF_Context_Group
1541  * @since 1.2.0
1542  */
1543 EAPI void
1544 ecore_imf_context_input_panel_imdata_set(Ecore_IMF_Context *ctx, const void *data, int len)
1545 {
1546    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1547      {
1548         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1549                          "ecore_imf_context_input_panel_imdata_set");
1550         return;
1551      }
1552
1553    if (!data) return;
1554
1555    if (ctx->klass->input_panel_imdata_set)
1556      ctx->klass->input_panel_imdata_set(ctx, data, len);
1557 }
1558
1559 /**
1560  * Get the specific data of the current active input panel.
1561  *
1562  * @param ctx An #Ecore_IMF_Context.
1563  * @param data The specific data to be got from the input panel
1564  * @param len The length of data
1565  * @ingroup Ecore_IMF_Context_Group
1566  * @since 1.2.0
1567  */
1568 EAPI void
1569 ecore_imf_context_input_panel_imdata_get(Ecore_IMF_Context *ctx, void *data, int *len)
1570 {
1571    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1572      {
1573         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1574                          "ecore_imf_context_input_panel_imdata_get");
1575         return;
1576      }
1577
1578    if (!data) return;
1579
1580    if (ctx->klass->input_panel_imdata_get)
1581      ctx->klass->input_panel_imdata_get(ctx, data, len);
1582 }
1583
1584 /**
1585  * Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.
1586  *
1587  * An input panel displays the string or icon associated with this type
1588  *
1589  * @param ctx An #Ecore_IMF_Context.
1590  * @param return_key_type The type of "return" key on the input panel
1591  * @ingroup Ecore_IMF_Context_Group
1592  * @since 1.2.0
1593  */
1594 EAPI void
1595 ecore_imf_context_input_panel_return_key_type_set(Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Return_Key_Type return_key_type)
1596 {
1597    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1598      {
1599         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1600                          "ecore_imf_context_input_panel_return_key_type_set");
1601         return;
1602      }
1603
1604    ctx->input_panel_return_key_type = return_key_type;
1605    if (ctx->klass->input_panel_return_key_type_set) ctx->klass->input_panel_return_key_type_set(ctx, return_key_type);
1606 }
1607
1608 /**
1609  * Get the "return" key type.
1610  *
1611  * @see ecore_imf_context_input_panel_return_key_type_set() for more details
1612  *
1613  * @param ctx An #Ecore_IMF_Context.
1614  * @return The type of "return" key on the input panel
1615  * @ingroup Ecore_IMF_Context_Group
1616  * @since 1.2.0
1617  */
1618 EAPI Ecore_IMF_Input_Panel_Return_Key_Type
1619 ecore_imf_context_input_panel_return_key_type_get(Ecore_IMF_Context *ctx)
1620 {
1621    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1622      {
1623         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1624                          "ecore_imf_context_input_panel_return_key_type_get");
1625         return EINA_FALSE;
1626      }
1627
1628    return ctx->input_panel_return_key_type;
1629 }
1630
1631 /**
1632  * Set the return key on the input panel to be disabled.
1633  *
1634  * @param ctx An #Ecore_IMF_Context.
1635  * @param disabled The state
1636  * @ingroup Ecore_IMF_Context_Group
1637  * @since 1.2.0
1638  */
1639 EAPI void
1640 ecore_imf_context_input_panel_return_key_disabled_set(Ecore_IMF_Context *ctx, Eina_Bool disabled)
1641 {
1642    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1643      {
1644         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1645                          "ecore_imf_context_input_panel_return_key_disabled_set");
1646         return;
1647      }
1648
1649    ctx->input_panel_return_key_disabled = disabled;
1650    if (ctx->klass->input_panel_return_key_disabled_set) ctx->klass->input_panel_return_key_disabled_set(ctx, disabled);
1651 }
1652
1653 /**
1654  * Get whether the return key on the input panel should be disabled or not.
1655  *
1656  * @param ctx An #Ecore_IMF_Context.
1657  * @return EINA_TRUE if it should be disabled
1658  * @ingroup Ecore_IMF_Context_Group
1659  * @since 1.2.0
1660  */
1661 EAPI Eina_Bool
1662 ecore_imf_context_input_panel_return_key_disabled_get(Ecore_IMF_Context *ctx)
1663 {
1664    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1665      {
1666         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1667                          "ecore_imf_context_input_panel_return_key_disabled_get");
1668         return EINA_FALSE;
1669      }
1670
1671    return ctx->input_panel_return_key_disabled;
1672 }
1673
1674 /**
1675  * Set the caps lock mode on the input panel.
1676  *
1677  * @param ctx An #Ecore_IMF_Context.
1678  * @param mode Turn on caps lock on the input panel if EINA_TRUE
1679  * @ingroup Ecore_IMF_Context_Group
1680  * @since 1.2.0
1681  */
1682 EAPI void
1683 ecore_imf_context_input_panel_caps_lock_mode_set(Ecore_IMF_Context *ctx, Eina_Bool mode)
1684 {
1685    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1686      {
1687         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1688                          "ecore_imf_context_input_panel_caps_lock_mode_set");
1689         return;
1690      }
1691
1692    if (ctx->klass->input_panel_caps_lock_mode_set)
1693      ctx->klass->input_panel_caps_lock_mode_set(ctx, mode);
1694
1695    ctx->input_panel_caps_lock_mode = mode;
1696 }
1697
1698 /**
1699  * Get the caps lock mode on the input panel.
1700  *
1701  * @param ctx An #Ecore_IMF_Context.
1702  * @return EINA_TRUE if the caps lock is turned on.
1703  * @ingroup Ecore_IMF_Context_Group
1704  * @since 1.2.0
1705  */
1706 EAPI Eina_Bool
1707 ecore_imf_context_input_panel_caps_lock_mode_get(Ecore_IMF_Context *ctx)
1708 {
1709    if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
1710      {
1711         ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
1712                          "ecore_imf_context_input_panel_caps_lock_mode_get");
1713         return EINA_FALSE;
1714      }
1715
1716    return ctx->input_panel_caps_lock_mode;
1717 }
1718