2009-01-31 10:33:39 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
#include <stdlib.h>
|
2009-01-31 10:33:39 -08:00
|
|
|
#include <string.h>
|
|
|
|
#include <locale.h>
|
2007-11-19 10:27:11 -08:00
|
|
|
|
2009-01-31 10:33:39 -08:00
|
|
|
#include <Ecore.h>
|
2009-03-10 15:44:36 -07:00
|
|
|
#include <ecore_private.h>
|
2007-11-19 10:27:11 -08:00
|
|
|
|
|
|
|
#include "Ecore_IMF.h"
|
|
|
|
#include "ecore_imf_private.h"
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @defgroup Ecore_IMF_Context_Group Ecore Input Method Context Functions
|
|
|
|
*
|
|
|
|
* Functions that operate on Ecore Input Method Context objects.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the list of the available Input Method Context ids.
|
|
|
|
*
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
* Note that the caller is responsible for freeing the Eina_List
|
2007-11-19 10:27:11 -08:00
|
|
|
* when finished with it. There is no need to finish the list strings.
|
|
|
|
*
|
2010-10-12 01:59:42 -07:00
|
|
|
* @return Return an Eina_List of strings;
|
2007-11-19 10:27:11 -08:00
|
|
|
* on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
EAPI Eina_List *
|
2007-11-19 10:27:11 -08:00
|
|
|
ecore_imf_context_available_ids_get(void)
|
|
|
|
{
|
|
|
|
return ecore_imf_module_context_ids_get();
|
|
|
|
}
|
|
|
|
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
EAPI Eina_List *
|
2007-11-21 14:20:16 -08:00
|
|
|
ecore_imf_context_available_ids_by_canvas_type_get(const char *canvas_type)
|
|
|
|
{
|
|
|
|
return ecore_imf_module_context_ids_by_canvas_type_get(canvas_type);
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
/*
|
|
|
|
* Match @locale against @against.
|
|
|
|
*
|
|
|
|
* 'en_US' against 'en_US' => 4
|
|
|
|
* 'en_US' against 'en' => 3
|
|
|
|
* 'en', 'en_UK' against 'en_US' => 2
|
|
|
|
* all locales, against '*' => 1
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
_ecore_imf_context_match_locale(const char *locale, const char *against, int against_len)
|
|
|
|
{
|
2011-04-11 04:31:55 -07:00
|
|
|
if (strcmp(against, "*") == 0)
|
|
|
|
return 1;
|
2007-11-19 10:27:11 -08:00
|
|
|
|
2011-04-11 04:31:55 -07:00
|
|
|
if (strcasecmp(locale, against) == 0)
|
|
|
|
return 4;
|
2007-11-19 10:27:11 -08:00
|
|
|
|
2011-04-11 04:31:55 -07:00
|
|
|
if (strncasecmp(locale, against, 2) == 0)
|
|
|
|
return (against_len == 2) ? 3 : 2;
|
2007-11-19 10:27:11 -08:00
|
|
|
|
2011-04-11 04:31:55 -07:00
|
|
|
return 0;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the id of the default Input Method Context.
|
|
|
|
* The id may to used to create a new instance of an Input Method
|
|
|
|
* Context object.
|
|
|
|
*
|
|
|
|
* @return Return a string containing the id of the default Input
|
|
|
|
* Method Context; on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
ecore_imf_context_default_id_get(void)
|
2007-11-21 14:20:16 -08:00
|
|
|
{
|
|
|
|
return ecore_imf_context_default_id_by_canvas_type_get(NULL);
|
|
|
|
}
|
|
|
|
|
2007-11-22 03:57:01 -08:00
|
|
|
EAPI const char *
|
|
|
|
ecore_imf_context_default_id_by_canvas_type_get(const char *canvas_type)
|
2007-11-19 10:27:11 -08:00
|
|
|
{
|
|
|
|
const char *id;
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
Eina_List *modules;
|
2007-11-19 10:27:11 -08:00
|
|
|
Ecore_IMF_Module *module;
|
|
|
|
char *locale;
|
|
|
|
char *tmp;
|
|
|
|
int best_goodness = 0;
|
|
|
|
|
|
|
|
id = getenv("ECORE_IMF_MODULE");
|
2008-04-24 08:28:53 -07:00
|
|
|
if (id)
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
if (strcmp(id, "none") == 0) return NULL;
|
|
|
|
if (ecore_imf_module_get(id)) return id;
|
2008-04-24 08:28:53 -07:00
|
|
|
}
|
2007-11-19 10:27:11 -08:00
|
|
|
|
|
|
|
modules = ecore_imf_module_available_get();
|
|
|
|
if (!modules) return NULL;
|
|
|
|
|
|
|
|
locale = setlocale(LC_CTYPE, NULL);
|
|
|
|
if (!locale) return NULL;
|
|
|
|
|
|
|
|
locale = strdup(locale);
|
|
|
|
|
|
|
|
tmp = strchr(locale, '.');
|
|
|
|
if (tmp) *tmp = '\0';
|
|
|
|
tmp = strchr(locale, '@');
|
|
|
|
if (tmp) *tmp = '\0';
|
|
|
|
|
|
|
|
id = NULL;
|
|
|
|
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
EINA_LIST_FREE(modules, module)
|
2007-11-19 10:27:11 -08:00
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
if (canvas_type &&
|
|
|
|
strcmp(module->info->canvas_type, canvas_type) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
const char *p = module->info->default_locales;
|
|
|
|
while (p)
|
|
|
|
{
|
|
|
|
const char *q = strchr(p, ':');
|
|
|
|
int goodness = _ecore_imf_context_match_locale(locale, p, q ? (size_t)(q - p) : strlen (p));
|
|
|
|
|
2011-04-11 04:31:55 -07:00
|
|
|
if (goodness > best_goodness)
|
|
|
|
{
|
|
|
|
id = module->info->id;
|
|
|
|
best_goodness = goodness;
|
|
|
|
}
|
2010-09-30 00:31:11 -07:00
|
|
|
|
2011-04-11 04:31:55 -07:00
|
|
|
p = q ? q + 1 : NULL;
|
2010-09-30 00:31:11 -07:00
|
|
|
}
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
free(locale);
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieve the info for the Input Method Context with @p id.
|
|
|
|
*
|
|
|
|
* @param id The Input Method Context id to query for.
|
|
|
|
* @return Return a #Ecore_IMF_Context_Info for the Input Method Context with @p id;
|
|
|
|
* on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI const Ecore_IMF_Context_Info *
|
|
|
|
ecore_imf_context_info_by_id_get(const char *id)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Module *module;
|
|
|
|
|
|
|
|
if (!id) return NULL;
|
|
|
|
module = ecore_imf_module_get(id);
|
|
|
|
if (!module) return NULL;
|
|
|
|
return module->info;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a new Input Method Context defined by the given id.
|
|
|
|
*
|
|
|
|
* @param id The Input Method Context id.
|
|
|
|
* @return A newly allocated Input Method Context;
|
|
|
|
* on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI Ecore_IMF_Context *
|
|
|
|
ecore_imf_context_add(const char *id)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Context *ctx;
|
|
|
|
|
|
|
|
if (!id) return NULL;
|
|
|
|
ctx = ecore_imf_module_context_create(id);
|
|
|
|
if (!ctx || !ctx->klass) return NULL;
|
|
|
|
if (ctx->klass->add) ctx->klass->add(ctx);
|
2010-09-29 02:29:36 -07:00
|
|
|
/* default use_preedit is EINA_TRUE, so let's make sure it's
|
2007-11-19 10:27:11 -08:00
|
|
|
* set on the immodule */
|
2010-09-29 02:29:36 -07:00
|
|
|
ecore_imf_context_use_preedit_set(ctx, EINA_TRUE);
|
2011-04-28 22:16:51 -07:00
|
|
|
|
|
|
|
/* default prediction is EINA_TRUE, so let's make sure it's
|
|
|
|
* set on the immodule */
|
|
|
|
ecore_imf_context_prediction_allow_set(ctx, EINA_TRUE);
|
|
|
|
|
|
|
|
/* default autocapital type is SENTENCE type, so let's make sure it's
|
|
|
|
* set on the immodule */
|
|
|
|
ecore_imf_context_autocapital_type_set(ctx, ECORE_IMF_AUTOCAPITAL_TYPE_SENTENCE);
|
|
|
|
|
2011-06-20 00:17:24 -07:00
|
|
|
/* default input panel enabled status is EINA_TRUE, so let's make sure it's
|
|
|
|
* set on the immodule */
|
|
|
|
ecore_imf_context_input_panel_enabled_set(ctx, EINA_TRUE);
|
|
|
|
|
2012-02-06 00:05:58 -08:00
|
|
|
/* default input panel layout type is NORMAL type, so let's make sure it's
|
|
|
|
* set on the immodule */
|
|
|
|
ecore_imf_context_input_panel_layout_set(ctx, ECORE_IMF_INPUT_PANEL_LAYOUT_NORMAL);
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
/* default input_mode is ECORE_IMF_INPUT_MODE_FULL, so let's make sure it's
|
|
|
|
* set on the immodule */
|
|
|
|
ecore_imf_context_input_mode_set(ctx, ECORE_IMF_INPUT_MODE_FULL);
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
2007-11-21 14:20:16 -08:00
|
|
|
/**
|
|
|
|
* Retrieve the info for the given Input Method Context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return Return a #Ecore_IMF_Context_Info for the given Input Method Context;
|
|
|
|
* on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI const Ecore_IMF_Context_Info *
|
|
|
|
ecore_imf_context_info_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_info_get");
|
|
|
|
return NULL;
|
2007-11-21 14:20:16 -08:00
|
|
|
}
|
|
|
|
return ctx->module->info;
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
/**
|
|
|
|
* Delete the given Input Method Context and free its memory.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_del(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
2012-01-17 20:38:04 -08:00
|
|
|
Ecore_IMF_Func_Node *fn;
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_del");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->del) ctx->klass->del(ctx);
|
2012-01-17 20:38:04 -08:00
|
|
|
|
|
|
|
if (ctx->callbacks)
|
|
|
|
{
|
|
|
|
EINA_LIST_FREE(ctx->callbacks, fn)
|
|
|
|
free(fn);
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
ECORE_MAGIC_SET(ctx, ECORE_MAGIC_NONE);
|
|
|
|
free(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the client window for the Input Method Context; this is the
|
2007-11-21 14:20:16 -08:00
|
|
|
* Ecore_X_Window when using X11, Ecore_Win32_Window when using Win32, etc.
|
2007-11-19 10:27:11 -08:00
|
|
|
* This window is used in order to correctly position status windows, and may
|
|
|
|
* also be used for purposes internal to the Input Method Context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param window The client window. This may be NULL to indicate
|
|
|
|
* that the previous client window no longer exists.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
2007-11-21 14:20:16 -08:00
|
|
|
ecore_imf_context_client_window_set(Ecore_IMF_Context *ctx, void *window)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_client_window_set");
|
|
|
|
return;
|
2007-11-21 14:20:16 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->client_window_set) ctx->klass->client_window_set(ctx, window);
|
2011-02-20 22:22:37 -08:00
|
|
|
ctx->window = window;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the client window of the Input Method Context
|
|
|
|
*
|
|
|
|
* See @ref ecore_imf_context_client_window_set for more details.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return Return the client window.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-02-22 06:58:47 -08:00
|
|
|
* @since 1.1.0
|
2011-02-20 22:22:37 -08:00
|
|
|
*/
|
|
|
|
EAPI void *
|
|
|
|
ecore_imf_context_client_window_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_client_window_get");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return ctx->window;
|
2007-11-21 14:20:16 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the client canvas for the Input Method Context; this is the
|
|
|
|
* canvas in which the input appears.
|
|
|
|
* The canvas type can be determined by using the context canvas type.
|
|
|
|
* Actually only canvas with type "evas" (Evas *) is supported.
|
|
|
|
* This canvas may be used in order to correctly position status windows, and may
|
|
|
|
* also be used for purposes internal to the Input Method Context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
2010-10-12 01:59:42 -07:00
|
|
|
* @param canvas The client canvas. This may be NULL to indicate
|
|
|
|
* that the previous client canvas no longer exists.
|
2007-11-21 14:20:16 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_client_canvas_set(Ecore_IMF_Context *ctx, void *canvas)
|
2007-11-19 10:27:11 -08:00
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_client_canvas_set");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
2007-11-21 14:20:16 -08:00
|
|
|
if (ctx->klass->client_canvas_set) ctx->klass->client_canvas_set(ctx, canvas);
|
2011-02-20 22:22:37 -08:00
|
|
|
ctx->client_canvas = canvas;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the client canvas of the Input Method Context.
|
|
|
|
*
|
|
|
|
* See @ref ecore_imf_context_client_canvas_set for more details.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return Return the client canvas.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-02-22 06:58:47 -08:00
|
|
|
* @since 1.1.0
|
2011-02-20 22:22:37 -08:00
|
|
|
*/
|
|
|
|
EAPI void *
|
|
|
|
ecore_imf_context_client_canvas_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_client_canvas_get");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return ctx->client_canvas;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ask the Input Method Context to show itself.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_show(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_show");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->show) ctx->klass->show(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ask the Input Method Context to hide itself.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_hide(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_hide");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->hide) ctx->klass->hide(ctx);
|
|
|
|
}
|
|
|
|
|
2010-10-12 01:59:42 -07:00
|
|
|
/**
|
2007-11-19 10:27:11 -08:00
|
|
|
* Retrieve the current preedit string and cursor position
|
|
|
|
* for the Input Method Context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param str Location to store the retrieved string. The
|
|
|
|
* string retrieved must be freed with free().
|
|
|
|
* @param cursor_pos Location to store position of cursor (in characters)
|
|
|
|
* within the preedit string.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_preedit_string_get(Ecore_IMF_Context *ctx, char **str, int *cursor_pos)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_preedit_string_get");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->preedit_string_get)
|
|
|
|
ctx->klass->preedit_string_get(ctx, str, cursor_pos);
|
|
|
|
else
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
if (str) *str = strdup("");
|
|
|
|
if (cursor_pos) *cursor_pos = 0;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-27 03:20:35 -08:00
|
|
|
/**
|
|
|
|
* Retrieve the current preedit string, atrributes and
|
|
|
|
* cursor position for the Input Method Context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param str Location to store the retrieved string. The
|
|
|
|
* string retrieved must be freed with free().
|
|
|
|
* @param attrs an Eina_List of attributes
|
|
|
|
* @param cursor_pos Location to store position of cursor (in characters)
|
|
|
|
* within the preedit string.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_preedit_string_with_attributes_get(Ecore_IMF_Context *ctx, char **str, Eina_List **attrs, int *cursor_pos)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_preedit_string_with_attributes_get");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (ctx->klass->preedit_string_with_attributes_get)
|
|
|
|
ctx->klass->preedit_string_with_attributes_get(ctx, str, attrs, cursor_pos);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (str) *str = strdup("");
|
|
|
|
if (attrs) *attrs = NULL;
|
|
|
|
if (cursor_pos) *cursor_pos = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
/**
|
|
|
|
* Notify the Input Method Context that the widget to which its
|
|
|
|
* correspond has gained focus.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_focus_in(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_focus_in");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->focus_in) ctx->klass->focus_in(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the Input Method Context that the widget to which its
|
|
|
|
* correspond has lost focus.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_focus_out(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_focus_out");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->focus_out) ctx->klass->focus_out(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the Input Method Context that a change such as a
|
|
|
|
* change in cursor position has been made. This will typically
|
|
|
|
* cause the Input Method Context to clear the preedit state.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_reset(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_reset");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->reset) ctx->klass->reset(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the Input Method Context that a change in the cursor
|
|
|
|
* position has been made.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param cursor_pos New cursor position in characters.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_cursor_position_set(Ecore_IMF_Context *ctx, int cursor_pos)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_cursor_position_set");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->cursor_position_set) ctx->klass->cursor_position_set(ctx, cursor_pos);
|
|
|
|
}
|
|
|
|
|
2011-07-06 23:23:46 -07:00
|
|
|
/**
|
|
|
|
* Notify the Input Method Context that a change in the cursor
|
|
|
|
* location has been made. The location is relative to the canvas.
|
2012-01-31 22:39:26 -08:00
|
|
|
* The cursor location can be used to determine the position of
|
|
|
|
* candidate word window in the immodule.
|
2011-07-06 23:23:46 -07:00
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param x cursor x position.
|
|
|
|
* @param x cursor y position.
|
|
|
|
* @param w cursor width.
|
|
|
|
* @param h cursor height.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-08-07 07:49:08 -07:00
|
|
|
* @since 1.1.0
|
2011-07-06 23:23:46 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_cursor_location_set(Ecore_IMF_Context *ctx, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
2011-07-07 02:37:55 -07:00
|
|
|
"ecore_imf_context_cursor_location_set");
|
2011-07-06 23:23:46 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (ctx->klass->cursor_location_set) ctx->klass->cursor_location_set(ctx, x, y, w, h);
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
/**
|
|
|
|
* Set whether the IM context should use the preedit string
|
2012-01-17 03:37:35 -08:00
|
|
|
* to display feedback. If @c use_preedit is EINA_FALSE (default
|
2010-09-29 02:29:36 -07:00
|
|
|
* is EINA_TRUE), then the IM context may use some other method to display
|
2007-11-19 10:27:11 -08:00
|
|
|
* feedback, such as displaying it in a child of the root window.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param use_preedit Whether the IM context should use the preedit string.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
2010-09-29 02:29:36 -07:00
|
|
|
ecore_imf_context_use_preedit_set(Ecore_IMF_Context *ctx, Eina_Bool use_preedit)
|
2007-11-19 10:27:11 -08:00
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_use_preedit_set");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->use_preedit_set) ctx->klass->use_preedit_set(ctx, use_preedit);
|
|
|
|
}
|
|
|
|
|
2011-04-28 22:16:51 -07:00
|
|
|
/**
|
|
|
|
* Set whether the IM context should allow to use the text prediction.
|
2012-01-17 03:37:35 -08:00
|
|
|
* If @c prediction is EINA_FALSE (default is EINA_TRUE), then the IM context will not display the text prediction window.
|
2011-04-28 22:16:51 -07:00
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param prediction Whether the IM context should allow to use the text prediction.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_prediction_allow_set(Ecore_IMF_Context *ctx, Eina_Bool prediction)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_prediction_allow_set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx->allow_prediction = prediction;
|
|
|
|
|
|
|
|
if (ctx->klass->prediction_allow_set)
|
|
|
|
ctx->klass->prediction_allow_set(ctx, prediction);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get whether the IM context should allow to use the text prediction.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return EINA_TRUE if it allows to use the text prediction, otherwise EINA_FALSE.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
ecore_imf_context_prediction_allow_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_prediction_allow_get");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ctx->allow_prediction;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the autocapitalization type on the immodule.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param autocapital_type the autocapitalization type.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_autocapital_type_set(Ecore_IMF_Context *ctx, Ecore_IMF_Autocapital_Type autocapital_type)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_autocapital_type_set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx->autocapital_type = autocapital_type;
|
|
|
|
|
|
|
|
if (ctx->klass->autocapital_type_set) ctx->klass->autocapital_type_set(ctx, autocapital_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the autocapitalization type.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return The autocapital type being used by @p ctx.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI Ecore_IMF_Autocapital_Type
|
|
|
|
ecore_imf_context_autocapital_type_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_autocapital_allow_get");
|
|
|
|
return ECORE_IMF_AUTOCAPITAL_TYPE_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ctx->autocapital_type;
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:27:11 -08:00
|
|
|
/**
|
|
|
|
* Set the callback to be used on get_surrounding request.
|
|
|
|
*
|
|
|
|
* This callback will be called when the Input Method Context
|
|
|
|
* module requests the surrounding context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param func The callback to be called.
|
|
|
|
* @param data The data pointer to be passed to @p func
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
2010-09-25 22:42:56 -07:00
|
|
|
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)
|
2007-11-19 10:27:11 -08:00
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_retrieve_surrounding_callback_set");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ctx->retrieve_surrounding_func = func;
|
|
|
|
ctx->retrieve_surrounding_data = (void *) data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the input mode used by the Ecore Input Context.
|
|
|
|
*
|
|
|
|
* The input mode can be one of the input modes defined in
|
|
|
|
* #Ecore_IMF_Input_Mode. The default input mode is
|
|
|
|
* ECORE_IMF_INPUT_MODE_FULL.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param input_mode The input mode to be used by @p ctx.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_input_mode_set(Ecore_IMF_Context *ctx, Ecore_IMF_Input_Mode input_mode)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_mode_set");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
if (ctx->klass->input_mode_set) ctx->klass->input_mode_set(ctx, input_mode);
|
|
|
|
ctx->input_mode = input_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the input mode being used by the Ecore Input Context.
|
|
|
|
*
|
|
|
|
* See @ref ecore_imf_context_input_mode_set for more details.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return The input mode being used by @p ctx.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
|
|
|
EAPI Ecore_IMF_Input_Mode
|
|
|
|
ecore_imf_context_input_mode_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_mode_set");
|
|
|
|
return 0;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
return ctx->input_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Allow an Ecore Input Context to internally handle an event.
|
2010-09-25 22:42:56 -07:00
|
|
|
* If this function returns EINA_TRUE, then no further processing
|
2007-11-19 10:27:11 -08:00
|
|
|
* should be done for this event.
|
|
|
|
*
|
|
|
|
* Input methods must be able to accept all types of events (simply
|
2010-09-25 22:42:56 -07:00
|
|
|
* returning EINA_FALSE if the event was not handled), but there is no
|
2007-11-19 10:27:11 -08:00
|
|
|
* obligation of any events to be submitted to this function.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
2007-11-21 14:20:16 -08:00
|
|
|
* @param type The type of event defined by #Ecore_IMF_Event_Type.
|
|
|
|
* @param event The event itself.
|
2010-09-29 03:55:40 -07:00
|
|
|
* @return EINA_TRUE if the event was handled; otherwise EINA_FALSE.
|
2007-11-19 10:27:11 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
*/
|
2010-09-25 22:42:56 -07:00
|
|
|
EAPI Eina_Bool
|
2007-11-21 14:20:16 -08:00
|
|
|
ecore_imf_context_filter_event(Ecore_IMF_Context *ctx, Ecore_IMF_Event_Type type, Ecore_IMF_Event *event)
|
2007-11-19 10:27:11 -08:00
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_filter_event");
|
|
|
|
return EINA_FALSE;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
2007-11-21 14:20:16 -08:00
|
|
|
if (ctx->klass->filter_event) return ctx->klass->filter_event(ctx, type, event);
|
2010-09-25 22:42:56 -07:00
|
|
|
return EINA_FALSE;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @defgroup Ecore_IMF_Context_Module_Group Ecore Input Method Context Module Functions
|
|
|
|
*
|
|
|
|
* Functions that should be used by Ecore Input Method Context modules.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new Input Method Context with klass specified by @p ctxc.
|
|
|
|
*
|
|
|
|
* This method should be used by modules implementing the Input
|
|
|
|
* Method Context interface.
|
|
|
|
*
|
|
|
|
* @param ctxc An #Ecore_IMF_Context_Class.
|
|
|
|
* @return A new #Ecore_IMF_Context; on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI Ecore_IMF_Context *
|
|
|
|
ecore_imf_context_new(const Ecore_IMF_Context_Class *ctxc)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Context *ctx;
|
|
|
|
|
2008-05-02 08:33:50 -07:00
|
|
|
if (!ctxc) return NULL;
|
2010-09-29 03:55:40 -07:00
|
|
|
ctx = calloc(1, sizeof(Ecore_IMF_Context));
|
2007-11-19 10:27:11 -08:00
|
|
|
if (!ctx) return NULL;
|
|
|
|
ECORE_MAGIC_SET(ctx, ECORE_MAGIC_CONTEXT);
|
|
|
|
ctx->klass = ctxc;
|
|
|
|
ctx->data = NULL;
|
|
|
|
ctx->retrieve_surrounding_func = NULL;
|
|
|
|
ctx->retrieve_surrounding_data = NULL;
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the Input Method Context specific data.
|
|
|
|
*
|
|
|
|
* Note that this method should be used by modules to set
|
|
|
|
* the Input Method Context specific data and it's not meant to
|
|
|
|
* be used by applications to store application specific data.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param data The Input Method Context specific data.
|
|
|
|
* @return A new #Ecore_IMF_Context; on failure it returns NULL.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_data_set(Ecore_IMF_Context *ctx, void *data)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_data_set");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
ctx->data = data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the Input Method Context specific data.
|
|
|
|
*
|
|
|
|
* See @ref ecore_imf_context_data_set for more details.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return The Input Method Context specific data.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void *ecore_imf_context_data_get(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_data_get");
|
|
|
|
return NULL;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
return ctx->data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieve context around insertion point.
|
|
|
|
*
|
|
|
|
* This function is implemented by calling the
|
|
|
|
* Ecore_IMF_Context::retrieve_surrounding_func (
|
|
|
|
* set using #ecore_imf_context_retrieve_surrounding_callback_set).
|
|
|
|
*
|
|
|
|
* There is no obligation for a widget to respond to the
|
|
|
|
* ::retrieve_surrounding_func, so input methods must be prepared
|
|
|
|
* to function without context.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param text Location to store a UTF-8 encoded string of text
|
|
|
|
* holding context around the insertion point.
|
2010-09-29 03:55:40 -07:00
|
|
|
* If the function returns EINA_TRUE, then you must free
|
2007-11-19 10:27:11 -08:00
|
|
|
* the result stored in this location with free().
|
|
|
|
* @param cursor_pos Location to store the position in characters of
|
|
|
|
* the insertion cursor within @text.
|
2010-09-25 22:42:56 -07:00
|
|
|
* @return EINA_TRUE if surrounding text was provided; otherwise EINA_FALSE.
|
2007-11-19 10:27:11 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
2010-09-25 22:42:56 -07:00
|
|
|
EAPI Eina_Bool
|
2007-11-19 10:27:11 -08:00
|
|
|
ecore_imf_context_surrounding_get(Ecore_IMF_Context *ctx, char **text, int *cursor_pos)
|
|
|
|
{
|
2010-09-25 22:42:56 -07:00
|
|
|
int result = EINA_FALSE;
|
2007-11-19 10:27:11 -08:00
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_surrounding_get");
|
|
|
|
return EINA_FALSE;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->retrieve_surrounding_func)
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
result = ctx->retrieve_surrounding_func(ctx->retrieve_surrounding_data, ctx, text, cursor_pos);
|
|
|
|
if (!result)
|
|
|
|
{
|
|
|
|
if (text) *text = NULL;
|
|
|
|
if (cursor_pos) *cursor_pos = 0;
|
|
|
|
}
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_imf_event_free_preedit(void *data __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
free(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds ECORE_IMF_EVENT_PREEDIT_START to the event queue.
|
|
|
|
*
|
2011-03-10 01:15:36 -08:00
|
|
|
* ECORE_IMF_EVENT_PREEDIT_START should be added when a new preedit sequence starts.
|
|
|
|
*
|
2007-11-19 10:27:11 -08:00
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_preedit_start_event_add(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Event_Commit *ev;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_preedit_start_event_add");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ev = malloc(sizeof(Ecore_IMF_Event_Preedit_Start));
|
|
|
|
ev->ctx = ctx;
|
|
|
|
ecore_event_add(ECORE_IMF_EVENT_PREEDIT_START,
|
2010-09-30 00:31:11 -07:00
|
|
|
ev, _ecore_imf_event_free_preedit, NULL);
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds ECORE_IMF_EVENT_PREEDIT_END to the event queue.
|
|
|
|
*
|
2011-03-10 01:15:36 -08:00
|
|
|
* ECORE_IMF_EVENT_PREEDIT_END should be added when a new preedit sequence has been completed or canceled.
|
|
|
|
*
|
2007-11-19 10:27:11 -08:00
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_preedit_end_event_add(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Event_Commit *ev;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_preedit_end_event_add");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ev = malloc(sizeof(Ecore_IMF_Event_Preedit_End));
|
|
|
|
ev->ctx = ctx;
|
|
|
|
ecore_event_add(ECORE_IMF_EVENT_PREEDIT_END,
|
2010-09-30 00:31:11 -07:00
|
|
|
ev, _ecore_imf_event_free_preedit, NULL);
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds ECORE_IMF_EVENT_PREEDIT_CHANGED to the event queue.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_preedit_changed_event_add(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Event_Commit *ev;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_preedit_changed_event_add");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ev = malloc(sizeof(Ecore_IMF_Event_Preedit_Changed));
|
|
|
|
ev->ctx = ctx;
|
|
|
|
ecore_event_add(ECORE_IMF_EVENT_PREEDIT_CHANGED,
|
2010-09-30 00:31:11 -07:00
|
|
|
ev, _ecore_imf_event_free_preedit, NULL);
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_imf_event_free_commit(void *data __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Event_Commit *ev;
|
|
|
|
|
|
|
|
ev = event;
|
|
|
|
if (ev->str) free(ev->str);
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds ECORE_IMF_EVENT_COMMIT to the event queue.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param str The committed string.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_commit_event_add(Ecore_IMF_Context *ctx, const char *str)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Event_Commit *ev;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_commit_event_add");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ev = malloc(sizeof(Ecore_IMF_Event_Commit));
|
|
|
|
ev->ctx = ctx;
|
|
|
|
ev->str = str ? strdup(str) : NULL;
|
|
|
|
ecore_event_add(ECORE_IMF_EVENT_COMMIT,
|
2010-09-30 00:31:11 -07:00
|
|
|
ev, _ecore_imf_event_free_commit, NULL);
|
2007-11-19 10:27:11 -08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_imf_event_free_delete_surrounding(void *data __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
free(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-12-12 11:00:48 -08:00
|
|
|
* Adds ECORE_IMF_EVENT_DELETE_SURROUNDING to the event queue.
|
2007-11-19 10:27:11 -08:00
|
|
|
*
|
2011-04-11 04:31:55 -07:00
|
|
|
* Asks the widget that the input context is attached to to delete characters around the cursor position
|
2011-03-10 01:15:36 -08:00
|
|
|
* by adding the ECORE_IMF_EVENT_DELETE_SURROUNDING to the event queue.
|
|
|
|
* Note that offset and n_chars are in characters not in bytes.
|
|
|
|
*
|
2007-11-19 10:27:11 -08:00
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param offset The start offset of surrounding to be deleted.
|
|
|
|
* @param n_chars The number of characters to be deleted.
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_delete_surrounding_event_add(Ecore_IMF_Context *ctx, int offset, int n_chars)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Event_Delete_Surrounding *ev;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
2010-09-30 00:31:11 -07:00
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_delete_surrounding_event_add");
|
|
|
|
return;
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ev = malloc(sizeof(Ecore_IMF_Event_Delete_Surrounding));
|
|
|
|
ev->ctx = ctx;
|
|
|
|
ev->offset = offset;
|
|
|
|
ev->n_chars = n_chars;
|
2007-12-12 11:00:48 -08:00
|
|
|
ecore_event_add(ECORE_IMF_EVENT_DELETE_SURROUNDING,
|
2010-09-30 00:31:11 -07:00
|
|
|
ev, _ecore_imf_event_free_delete_surrounding, NULL);
|
2007-11-19 10:27:11 -08:00
|
|
|
}
|
2011-06-02 00:56:58 -07:00
|
|
|
|
2012-01-17 20:38:04 -08:00
|
|
|
/**
|
|
|
|
* Add (register) a callback function to a given context event.
|
|
|
|
*
|
|
|
|
* This function adds a function callback to the context @p ctx when the
|
|
|
|
* event of type @p type occurs on it. The function pointer is @p
|
|
|
|
* func.
|
|
|
|
*
|
|
|
|
* The event type @p type to trigger the function may be one of
|
|
|
|
* #ECORE_IMF_CALLBACK_PREEDIT_START, #ECORE_IMF_CALLBACK_PREEDIT_END,
|
|
|
|
* #ECORE_IMF_CALLBACK_PREEDIT_CHANGED, #ECORE_IMF_CALLBACK_COMMIT and
|
|
|
|
* #ECORE_IMF_CALLBACK_DELETE_SURROUNDING.
|
|
|
|
*
|
|
|
|
* @param ctx Ecore_IMF_Context to attach a callback to.
|
|
|
|
* @param type The type of event that will trigger the callback
|
|
|
|
* @param func The (callback) function to be called when the event is
|
|
|
|
* triggered
|
|
|
|
* @param data The data pointer to be passed to @p func
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2012-01-17 20:38:04 -08:00
|
|
|
* @since 1.2.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_event_callback_add(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, Ecore_IMF_Event_Cb func, const void *data)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Func_Node *fn = NULL;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_event_callback_add");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!func) return;
|
|
|
|
|
|
|
|
fn = calloc(1, sizeof (Ecore_IMF_Func_Node));
|
|
|
|
if (!fn) return;
|
|
|
|
|
|
|
|
fn->func = func;
|
|
|
|
fn->data = data;
|
|
|
|
fn->type = type;
|
|
|
|
|
|
|
|
ctx->callbacks = eina_list_append(ctx->callbacks, fn);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete (unregister) a callback function registered to a given
|
|
|
|
* context event.
|
|
|
|
*
|
|
|
|
* This function removes a function callback from the context @p ctx when the
|
|
|
|
* event of type @p type occurs on it. The function pointer is @p
|
|
|
|
* func.
|
|
|
|
*
|
|
|
|
* @see ecore_imf_context_event_callback_add() for more details
|
|
|
|
*
|
|
|
|
* @param ctx Ecore_IMF_Context to remove a callback from.
|
|
|
|
* @param type The type of event that was trigerring the callback
|
|
|
|
* @param func The (callback) function that was to be called when the event was triggered
|
|
|
|
* @return the data pointer
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2012-01-17 20:38:04 -08:00
|
|
|
* @since 1.2.0
|
|
|
|
*/
|
|
|
|
EAPI void *
|
|
|
|
ecore_imf_context_event_callback_del(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, Ecore_IMF_Event_Cb func)
|
|
|
|
{
|
|
|
|
Eina_List *l = NULL;
|
|
|
|
Eina_List *l_next = NULL;
|
|
|
|
Ecore_IMF_Func_Node *fn = NULL;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_event_callback_del");
|
2012-01-29 05:39:07 -08:00
|
|
|
return NULL;
|
2012-01-17 20:38:04 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!func) return NULL;
|
|
|
|
if (!ctx->callbacks) return NULL;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH_SAFE(ctx->callbacks, l, l_next, fn)
|
|
|
|
{
|
|
|
|
if ((fn) && (fn->func == func) && (fn->type == type))
|
|
|
|
{
|
2012-01-29 05:39:07 -08:00
|
|
|
void *tmp = (void *)fn->data;
|
2012-01-17 20:38:04 -08:00
|
|
|
free(fn);
|
|
|
|
ctx->callbacks = eina_list_remove_list(ctx->callbacks, l);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call a given callback on the context @p ctx.
|
|
|
|
*
|
|
|
|
* ecore_imf_context_preedit_start_event_add, ecore_imf_context_preedit_end_event_add,
|
|
|
|
* ecore_imf_context_preedit_changed_event_add, ecore_imf_context_commit_event_add and
|
|
|
|
* ecore_imf_context_delete_surrounding_event_add APIs are asynchronous
|
|
|
|
* because those API adds each event to the event queue.
|
|
|
|
*
|
|
|
|
* This API provides the way to call each callback function immediately.
|
|
|
|
*
|
|
|
|
* @param ctx Ecore_IMF_Context.
|
|
|
|
* @param type The type of event that will trigger the callback
|
|
|
|
* @param event_info The pointer to event specific struct or information to
|
|
|
|
* pass to the callback functions registered on this event
|
|
|
|
* @ingroup Ecore_IMF_Context_Module_Group
|
|
|
|
* @since 1.2.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_event_callback_call(Ecore_IMF_Context *ctx, Ecore_IMF_Callback_Type type, void *event_info)
|
|
|
|
{
|
|
|
|
Ecore_IMF_Func_Node *fn = NULL;
|
|
|
|
Eina_List *l = NULL;
|
|
|
|
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_event_callback_call");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(ctx->callbacks, l, fn)
|
|
|
|
{
|
|
|
|
if ((fn) && (fn->type == type) && (fn->func))
|
|
|
|
fn->func(fn->data, ctx, event_info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-02 00:56:58 -07:00
|
|
|
/**
|
|
|
|
* Ask the Input Method Context to show the control panel of using Input Method.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-06-02 00:56:58 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_control_panel_show (Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_control_panel_show");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->control_panel_show) ctx->klass->control_panel_show(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ask the Input Method Context to hide the control panel of using Input Method.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-06-02 00:56:58 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_control_panel_hide (Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_control_panel_hide");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->control_panel_hide) ctx->klass->control_panel_hide(ctx);
|
|
|
|
}
|
|
|
|
|
2011-07-07 04:55:05 -07:00
|
|
|
/**
|
|
|
|
* Ask the Input Method Context to show the input panel (virtual keyboard).
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-07-07 04:55:05 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_input_panel_show(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_show");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->show) ctx->klass->show(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ask the Input Method Context to hide the input panel.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-07-07 04:55:05 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_input_panel_hide(Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_hide");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->hide) ctx->klass->hide(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the layout of the input panel.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param layout see #ECORE_IMF_INPUT_PANEL_LAYOUT
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-07-07 04:55:05 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_input_panel_layout_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Layout layout)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_layout_set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->input_panel_layout_set)
|
|
|
|
ctx->klass->input_panel_layout_set(ctx, layout);
|
|
|
|
|
|
|
|
ctx->input_panel_layout = layout;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the layout of the current active input panel.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return layout see #Ecore_IMF_Input_Panel_Layout
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-07-07 04:55:05 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI Ecore_IMF_Input_Panel_Layout
|
|
|
|
ecore_imf_context_input_panel_layout_get (Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_layout_get");
|
|
|
|
return ECORE_IMF_INPUT_PANEL_LAYOUT_INVALID;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->input_panel_layout_get)
|
|
|
|
{
|
|
|
|
return ctx->input_panel_layout;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return ECORE_IMF_INPUT_PANEL_LAYOUT_INVALID;
|
|
|
|
}
|
|
|
|
|
2011-06-02 00:56:58 -07:00
|
|
|
/**
|
|
|
|
* Set the language of the input panel.
|
|
|
|
* This API can be used when you want to show the English keyboard.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param lang the language to be set to the input panel.
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-06-02 00:56:58 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_input_panel_language_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Lang lang)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_language_set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->klass->input_panel_language_set) ctx->klass->input_panel_language_set(ctx, lang);
|
|
|
|
ctx->input_panel_lang = lang;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the language of the input panel.
|
|
|
|
*
|
|
|
|
* See @ref ecore_imf_context_input_panel_language_set for more details.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return Ecore_IMF_Input_Panel_Lang
|
2012-02-03 02:12:13 -08:00
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
2011-06-02 00:56:58 -07:00
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI Ecore_IMF_Input_Panel_Lang
|
|
|
|
ecore_imf_context_input_panel_language_get (Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_language_get");
|
|
|
|
return ECORE_IMF_INPUT_PANEL_LANG_AUTOMATIC;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ctx->input_panel_lang;
|
|
|
|
}
|
|
|
|
|
2011-06-20 00:17:24 -07:00
|
|
|
/**
|
|
|
|
* Set whether the Input Method Context should request to show the input panel automatically
|
|
|
|
* when the widget has focus.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @param enabled If true, the input panel will be shown when the widget is clicked or has focus.
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
ecore_imf_context_input_panel_enabled_set (Ecore_IMF_Context *ctx,
|
|
|
|
Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_enabled_set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx->input_panel_enabled = enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get whether the Input Method Context requests to show the input panel automatically.
|
|
|
|
*
|
|
|
|
* @param ctx An #Ecore_IMF_Context.
|
|
|
|
* @return Return the attribute to show the input panel automatically
|
|
|
|
* @ingroup Ecore_IMF_Context_Group
|
|
|
|
* @since 1.1.0
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
ecore_imf_context_input_panel_enabled_get (Ecore_IMF_Context *ctx)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
|
|
|
|
{
|
|
|
|
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,
|
|
|
|
"ecore_imf_context_input_panel_enabled_get");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ctx->input_panel_enabled;
|
|
|
|
}
|
|
|
|
|