inputmethod/src/inputmethod.cpp

   1 /*
   2  * Copyright (c) 2015-2021 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vector>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <dlog.h>
  22 #include <sclcore.h>
  23 #include <unistd.h>
  24 #include <privilege_checker_private.h>
  25 #include "inputmethod_private.h"
  26 #include <inputmethod.h>
  27 #include "inputmethod_internal.h"
  28
  29 using namespace std;
  30
  31 #ifdef LOG_TAG
  32 #undef LOG_TAG
  33 #endif
  34 #define LOG_TAG "INPUTMETHOD"
  35
  36 using namespace scl;
  37
  38 class CCoreEventCallback : public ISCLCoreEventCallback
  39 {
  40     void on_init();
  41     void on_run(int argc, char **argv);
  42     void on_exit();
  43     void on_update_cursor_position(sclint ic, const sclchar *ic_uuid, sclint cursor_pos);
  44     void on_update_surrounding_text(sclint ic, const sclchar *text, sclint cursor);
  45     void on_focus_out(sclint ic, const sclchar *ic_uuid);
  46     void on_focus_in(sclint ic, const sclchar *ic_uuid);
  47     void on_ise_show(sclint ic, const int degree, Ise_Context &context);
  48     void on_ise_hide(sclint ic, const sclchar *ic_uuid);
  49     void on_get_geometry(sclu32 *pos_x, sclu32 *pos_y, sclu32 *width, sclu32 *height);
  50     void on_set_language(sclu32 language);
  51     void on_set_imdata(sclchar *buf, sclu32 len);
  52     void on_get_imdata(sclchar **buf, sclu32 *len);
  53     void on_get_language_locale(sclint ic, sclchar **locale);
  54     void on_set_return_key_type(sclu32 type);
  55     void on_set_return_key_disable(sclu32 disabled);
  56     void on_set_layout(sclu32 layout);
  57     void on_reset_input_context(sclint ic, const sclchar *uuid);
  58     void on_process_key_event(scim::KeyEvent &key, sclu32 *ret);
  59     void on_process_key_event_with_keycode(scim::KeyEvent &key, sclu32 *ret, sclu32 keycode);
  60     void on_set_display_language(const sclchar *language);
  61     void on_set_rotation_degree(sclint degree);
  62     void on_set_accessibility_state(sclboolean state);
  63     void on_create_option_window(sclwindow window, SCLOptionWindowType type);
  64     void on_destroy_option_window(sclwindow window);
  65     void on_check_option_window_availability(sclboolean *ret);
  66     void on_set_caps_mode(sclu32 mode);
  67     void on_candidate_show(sclint ic, const sclchar *ic_uuid);
  68     void on_candidate_hide(sclint ic, const sclchar *ic_uuid);
  69     void on_update_lookup_table(SclCandidateTable &table);
  70     void on_process_input_device_event(sclu32 &type, sclchar *data, size_t &len, sclu32 *ret);
  71     void on_set_prediction_hint(const sclchar *prediction_hint);
  72     void on_set_mime_type(const sclchar *mime_type);
  73     void on_set_prediction_hint_data(const sclchar *key, const sclchar *value);
  74     void on_set_optimization_hint(sclu32 hint);
  75     void on_process_key_event_with_imengine(scim::KeyEvent &key, sclu32 serial);
  76     void on_set_autocapital_type(sclu32 type);
  77     void on_set_prediction_allow(sclu32 prediction_allow);
  78     void on_trigger_property(const sclchar *property);
  79     void on_candidate_more_window_show(sclint ic, const sclchar *uuid);
  80     void on_candidate_more_window_hide(sclint ic, const sclchar *uuid);
  81     void on_select_aux(sclint ic, const sclchar *uuid, sclint index);
  82     void on_select_candidate(sclint ic, const sclchar *uuid, sclint index);
  83     void on_candidate_table_page_up(sclint ic, const sclchar *uuid);
  84     void on_candidate_table_page_down(sclint ic, const sclchar *uuid);
  85     void on_update_candidate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size);
  86     void on_update_candidate_item_layout(const std::vector<sclu32> item);
  87     void on_update_displayed_candidate_number(sclu32 size);
  88     void on_longpress_candidate(sclu32 index);
  89 };
  90
  91 typedef struct
  92 {
  93     ime_focus_in_cb focus_in;   /**< Called when an edit field has focus */
  94     ime_focus_out_cb focus_out; /**< Called when an edit field loses focus */
  95     ime_surrounding_text_updated_cb surrounding_text_updated;   /**< Called when an edit field responds to a request with the surrounding text */
  96     ime_input_context_reset_cb input_context_reset;             /**< Called to reset the input context of an edit field */
  97     ime_cursor_position_updated_cb cursor_position_updated;     /**< Called when the position of the cursor in an edit field changes */
  98     ime_language_requested_cb language_requested;   /**< Called when an edit field requests the language from the input panel */
  99     ime_language_set_cb language_set;   /**< Called to set the preferred language to the input panel */
 100     ime_imdata_set_cb imdata_set;       /**< Called to set the application specific data to deliver to the input panel */
 101     ime_imdata_requested_cb imdata_requested;       /**< Called when an associated text input UI control requests the application specific data from the input panel */
 102     ime_layout_set_cb layout_set;       /**< Called when an edit field requests the input panel to set its layout */
 103     ime_return_key_type_set_cb return_key_type_set;     /**< Called when an edit field requests the input panel to set the "return" key label */
 104     ime_return_key_state_set_cb return_key_state_set;   /**< Called when an edit field requests the input panel to enable or disable the "return" key state */
 105     ime_geometry_requested_cb geometry_requested;       /**< Called when an edit field requests the position and size from the input panel */
 106     ime_process_key_event_cb process_key_event;         /**< Called when the key event is received from the external keyboard devices */
 107     ime_process_key_event_with_keycode_cb process_key_event_with_keycode; /**< Called when the key event is received from the external keyboard devices */
 108     ime_display_language_changed_cb display_language_changed;   /**< Called when the system display language is changed */
 109     ime_rotation_degree_changed_cb rotation_degree_changed;     /**< Called when the device is rotated */
 110     ime_accessibility_state_changed_cb accessibility_state_changed; /**< Called when Accessibility in Settings application is on or off */
 111     ime_option_window_created_cb option_window_created;     /**< Called to create the option window */
 112     ime_option_window_destroyed_cb option_window_destroyed; /**< Called to destroy the option window */
 113     ime_caps_mode_changed_cb caps_mode_changed;
 114     ime_candidate_show_cb candidate_show;
 115     ime_candidate_hide_cb candidate_hide;
 116     ime_lookup_table_changed_cb lookup_table_changed;
 117     ime_process_input_device_event_cb process_input_device_event;   /**< Called when the event is received from the unconventional input devices */
 118     ime_prediction_hint_set_cb prediction_hint_set;
 119     ime_mime_type_set_request_cb mime_type_set;
 120     ime_prediction_hint_data_set_cb prediction_hint_data_set;
 121     ime_optimization_hint_set_cb optimization_hint_set;
 122     ime_process_key_event_with_imengine_cb process_key_event_with_imengine;
 123     ime_autocapital_type_set_cb autocapital_type_set;
 124     ime_prediction_allow_set_cb prediction_allow_set;
 125     ime_trigger_property_set_cb trigger_property_set;
 126     ime_candidate_more_window_show_cb candidate_more_window_show;
 127     ime_candidate_more_window_hide_cb candidate_more_window_hide;
 128     ime_aux_select_cb aux_select;
 129     ime_candidate_select_cb candidate_select;
 130     ime_candidate_table_page_up_cb candidate_table_page_up;
 131     ime_candidate_table_page_down_cb candidate_table_page_down;
 132     ime_candidate_table_page_size_chaned_cb candidate_table_page_size_chaned;
 133     ime_candidate_item_layout_set_cb candidate_item_layout_set;
 134     ime_displayed_candidate_number_chaned_cb displayed_candidate_number_chaned;
 135     ime_candidate_item_long_pressed_cb candidate_item_long_pressed;
 136     void *focus_in_user_data;
 137     void *focus_out_user_data;
 138     void *surrounding_text_updated_user_data;
 139     void *input_context_reset_user_data;
 140     void *cursor_position_updated_user_data;
 141     void *language_requested_user_data;
 142     void *language_set_user_data;
 143     void *imdata_set_user_data;
 144     void *imdata_requested_user_data;
 145     void *layout_set_user_data;
 146     void *return_key_type_set_user_data;
 147     void *return_key_state_set_user_data;
 148     void *geometry_requested_user_data;
 149     void *process_key_event_user_data;
 150     void *process_key_event_with_keycode_user_data;
 151     void *display_language_changed_user_data;
 152     void *rotation_degree_changed_user_data;
 153     void *accessibility_state_changed_user_data;
 154     void *option_window_created_user_data;
 155     void *option_window_destroyed_user_data;
 156     void *caps_mode_changed_user_data;
 157     void *candidate_show_user_data;
 158     void *candidate_hide_user_data;
 159     void *lookup_table_changed_user_data;
 160     void *process_input_device_event_user_data;
 161     void *prediction_hint_set_user_data;
 162     void *mime_type_set_user_data;
 163     void *prediction_hint_data_set_user_data;
 164     void *optimization_hint_set_user_data;
 165     void *process_key_event_with_imengine_user_data;
 166     void *autocapital_type_set_user_data;
 167     void *prediction_allow_set_user_data;
 168     void *trigger_property_set_user_data;
 169     void *candidate_more_window_show_user_data;
 170     void *candidate_more_window_hide_user_data;
 171     void *aux_select_user_data;
 172     void *candidate_select_user_data;
 173     void *candidate_table_page_up_user_data;
 174     void *candidate_table_page_down_user_data;
 175     void *candidate_table_page_size_chaned_user_data;
 176     void *candidate_item_layout_set_user_data;
 177     void *displayed_candidate_number_chaned_user_data;
 178     void *candidate_item_long_pressed_user_data;
 179 } ime_event_callback_s;
 180
 181 typedef struct {
 182     ime_input_device_type_e device_type;
 183     void *event_data;
 184 } ime_device_event_s;
 185
 186 static ime_callback_s g_basic_callback = {NULL};
 187 static ime_event_callback_s g_event_callback = {NULL};
 188 static void *g_user_data = NULL;
 189 static bool g_running = false;
 190
 191 static CCoreEventCallback g_core_event_callback;
 192 CSCLCore g_core(&g_core_event_callback);
 193
 194 static bool g_checked_privilege = false;
 195 static bool g_permission_allowed = false;
 196
 197 extern "C" {
 198     extern void ime_app_main(int argc, char **argv);
 199 }
 200
 201 //LCOV_EXCL_START
 202 void CCoreEventCallback::on_init()
 203 {
 204     if (g_basic_callback.create) {
 205         g_basic_callback.create(g_user_data);
 206     }
 207 }
 208
 209 void CCoreEventCallback::on_run(int argc, char **argv)
 210 {
 211     LOGD("on_run");
 212     ime_app_main(argc, argv);
 213 }
 214
 215 void CCoreEventCallback::on_exit()
 216 {
 217     LOGD("on_exit");
 218     if (g_basic_callback.terminate) {
 219         g_basic_callback.terminate(g_user_data);
 220     }
 221 }
 222
 223 void CCoreEventCallback::on_update_cursor_position(sclint ic, const sclchar *ic_uuid, sclint cursor_pos)
 224 {
 225     if (g_event_callback.cursor_position_updated) {
 226         g_event_callback.cursor_position_updated(cursor_pos, g_event_callback.cursor_position_updated_user_data);
 227     }
 228 }
 229
 230 void CCoreEventCallback::on_update_surrounding_text(sclint ic, const sclchar *text, sclint cursor)
 231 {
 232     if (g_event_callback.surrounding_text_updated) {
 233         g_event_callback.surrounding_text_updated(ic, text, cursor, g_event_callback.surrounding_text_updated_user_data);
 234     }
 235 }
 236
 237 void CCoreEventCallback::on_focus_out(sclint ic, const sclchar *ic_uuid)
 238 {
 239     if (g_event_callback.focus_out) {
 240         g_event_callback.focus_out(ic, g_event_callback.focus_out_user_data);
 241     }
 242 }
 243
 244 void CCoreEventCallback::on_focus_in(sclint ic, const sclchar *ic_uuid)
 245 {
 246     if (g_event_callback.focus_in) {
 247         g_event_callback.focus_in(ic, g_event_callback.focus_in_user_data);
 248     }
 249 }
 250
 251 void CCoreEventCallback::on_ise_show(sclint ic, const int degree, Ise_Context &context)
 252 {
 253     if (g_basic_callback.show) {
 254         struct _ime_context input_context;
 255
 256         memset(&input_context, 0, sizeof(struct _ime_context));
 257         input_context.layout = context.layout;
 258         input_context.layout_variation = context.layout_variation;
 259         input_context.cursor_pos = context.cursor_pos;
 260         input_context.autocapital_type = context.autocapital_type;
 261         input_context.return_key_type = context.return_key_type;
 262         input_context.return_key_disabled = context.return_key_disabled;
 263         input_context.prediction_allow = context.prediction_allow;
 264         input_context.password_mode = context.password_mode;
 265         input_context.imdata_size = context.imdata_size;
 266         input_context.input_hint = context.input_hint;
 267         input_context.bidi_direction = context.bidi_direction;
 268         input_context.language = context.language;
 269         input_context.client_window = context.client_window;
 270         input_context.caps_mode = context.caps_mode;
 271
 272         g_basic_callback.show(ic, static_cast<ime_context_h>(&input_context), g_user_data);
 273     }
 274 }
 275
 276 void CCoreEventCallback::on_ise_hide(sclint ic, const sclchar *ic_uuid)
 277 {
 278     if (g_basic_callback.hide) {
 279         g_basic_callback.hide(ic, g_user_data);
 280     }
 281 }
 282
 283 void CCoreEventCallback::on_get_geometry(sclu32 *pos_x, sclu32 *pos_y, sclu32 *width, sclu32 *height)
 284 {
 285     int geometry_pos_x = 0;
 286     int geometry_pos_y = 0;
 287     int geometry_width = 0;
 288     int geometry_height = 0;
 289
 290     if (g_event_callback.geometry_requested) {
 291         g_event_callback.geometry_requested(g_event_callback.geometry_requested_user_data, &geometry_pos_x, &geometry_pos_y, &geometry_width, &geometry_height);
 292     }
 293
 294     if (pos_x)
 295         *pos_x = geometry_pos_x;
 296
 297     if (pos_y)
 298         *pos_y = geometry_pos_y;
 299
 300     if (width)
 301         *width = geometry_width;
 302
 303     if (height)
 304         *height = geometry_height;
 305 }
 306
 307 void CCoreEventCallback::on_set_language(sclu32 language)
 308 {
 309     if (g_event_callback.language_set) {
 310         g_event_callback.language_set((Ecore_IMF_Input_Panel_Lang)language, g_event_callback.language_set_user_data);
 311     }
 312 }
 313
 314 void CCoreEventCallback::on_set_imdata(sclchar *buf, sclu32 len)
 315 {
 316     if (g_event_callback.imdata_set) {
 317         g_event_callback.imdata_set((void *)buf, len, g_event_callback.imdata_set_user_data);
 318     }
 319 }
 320
 321 void CCoreEventCallback::on_get_imdata(sclchar **buf, sclu32 *len)
 322 {
 323     if (g_event_callback.imdata_requested) {
 324         g_event_callback.imdata_requested(g_event_callback.imdata_set_user_data, (void **)buf, len);
 325     }
 326 }
 327
 328 void CCoreEventCallback::on_get_language_locale(sclint ic, sclchar **locale)
 329 {
 330     if (g_event_callback.language_requested) {
 331         g_event_callback.language_requested(g_event_callback.language_requested_user_data, locale);
 332     }
 333 }
 334
 335 void CCoreEventCallback::on_set_return_key_type(sclu32 type)
 336 {
 337     if (g_event_callback.return_key_type_set) {
 338         g_event_callback.return_key_type_set((Ecore_IMF_Input_Panel_Return_Key_Type)type, g_event_callback.return_key_type_set_user_data);
 339     }
 340 }
 341
 342 void CCoreEventCallback::on_set_return_key_disable(sclu32 disabled)
 343 {
 344     bool return_key_disabled = !!disabled;
 345
 346     if (g_event_callback.return_key_state_set) {
 347         g_event_callback.return_key_state_set(return_key_disabled, g_event_callback.return_key_state_set_user_data);
 348     }
 349 }
 350
 351 void CCoreEventCallback::on_set_layout(sclu32 layout)
 352 {
 353     if (g_event_callback.layout_set) {
 354         g_event_callback.layout_set(static_cast<Ecore_IMF_Input_Panel_Layout>(layout), g_event_callback.layout_set_user_data);
 355     }
 356 }
 357
 358 void CCoreEventCallback::on_reset_input_context(sclint ic, const sclchar *uuid)
 359 {
 360     if (g_event_callback.input_context_reset) {
 361         g_event_callback.input_context_reset(g_event_callback.input_context_reset_user_data);
 362     }
 363 }
 364
 365 void CCoreEventCallback::on_process_key_event(scim::KeyEvent &key, sclu32 *ret)
 366 {
 367     if (g_event_callback.process_key_event) {
 368         struct _ime_device_info dev_info = {key.dev_name.c_str(),
 369             static_cast<Ecore_IMF_Device_Class>(key.dev_class), static_cast<Ecore_IMF_Device_Subclass>(key.dev_subclass)};
 370         bool processed = g_event_callback.process_key_event(static_cast<ime_key_code_e>(key.code), static_cast<ime_key_mask_e>(key.mask),
 371             static_cast<ime_device_info_h>(&dev_info), g_event_callback.process_key_event_user_data);
 372
 373         if (ret) {
 374             if (processed)
 375                 *ret = 1;
 376             else
 377                 *ret = 0;
 378         }
 379     } else {
 380         if (ret) {
 381             *ret = 0;
 382         }
 383     }
 384 }
 385
 386 void CCoreEventCallback::on_process_key_event_with_keycode(scim::KeyEvent &key, sclu32 *ret, sclu32 keycode)
 387 {
 388     if (g_event_callback.process_key_event_with_keycode) {
 389         struct _ime_device_info dev_info = {key.dev_name.c_str(),
 390             static_cast<Ecore_IMF_Device_Class>(key.dev_class), static_cast<Ecore_IMF_Device_Subclass>(key.dev_subclass)};
 391         bool processed = g_event_callback.process_key_event_with_keycode(keycode, static_cast<ime_key_code_e>(key.code), static_cast<ime_key_mask_e>(key.mask),
 392                 static_cast<ime_device_info_h>(&dev_info), g_event_callback.process_key_event_user_data);
 393
 394         if (ret) {
 395             if (processed)
 396                 *ret = 1;
 397             else
 398                 *ret = 0;
 399         }
 400     } else {
 401         if (ret) {
 402             *ret = 0;
 403         }
 404     }
 405 }
 406
 407 void CCoreEventCallback::on_set_display_language(const sclchar *language)
 408 {
 409     if (g_event_callback.display_language_changed) {
 410         g_event_callback.display_language_changed(language, g_event_callback.display_language_changed_user_data);
 411     }
 412 }
 413
 414 void CCoreEventCallback::on_set_rotation_degree(sclint degree)
 415 {
 416     if (g_event_callback.rotation_degree_changed) {
 417         g_event_callback.rotation_degree_changed(degree, g_event_callback.rotation_degree_changed_user_data);
 418     }
 419 }
 420
 421 void CCoreEventCallback::on_set_accessibility_state(sclboolean state)
 422 {
 423     if (g_event_callback.accessibility_state_changed) {
 424         g_event_callback.accessibility_state_changed(state, g_event_callback.accessibility_state_changed_user_data);
 425     }
 426 }
 427
 428 void CCoreEventCallback::on_create_option_window(sclwindow window, SCLOptionWindowType type)
 429 {
 430     if (g_event_callback.option_window_created) {
 431         g_event_callback.option_window_created(static_cast<Evas_Object*>(window), static_cast<ime_option_window_type_e>(type), g_event_callback.option_window_created_user_data);
 432     }
 433 }
 434
 435 void CCoreEventCallback::on_destroy_option_window(sclwindow window)
 436 {
 437     if (g_event_callback.option_window_destroyed) {
 438         g_event_callback.option_window_destroyed(static_cast<Evas_Object*>(window), g_event_callback.option_window_destroyed_user_data);
 439     }
 440 }
 441
 442 void CCoreEventCallback::on_check_option_window_availability(sclboolean *ret)
 443 {
 444     if (ret) {
 445         if (g_event_callback.option_window_created) // Instead of each 3rd party keyboard, inputmethod will reply the availability of the option (setting).
 446             *ret = true;
 447         else
 448             *ret = false;
 449     }
 450 }
 451
 452 void CCoreEventCallback::on_set_caps_mode(sclu32 mode)
 453 {
 454     if (g_event_callback.caps_mode_changed) {
 455         g_event_callback.caps_mode_changed(mode, g_event_callback.caps_mode_changed_user_data);
 456     }
 457 }
 458
 459 void CCoreEventCallback::on_candidate_show(sclint ic, const sclchar *ic_uuid)
 460 {
 461     if (g_event_callback.candidate_show) {
 462         g_event_callback.candidate_show(ic, g_event_callback.candidate_show_user_data);
 463     }
 464 }
 465
 466 void CCoreEventCallback::on_candidate_hide(sclint ic, const sclchar *ic_uuid)
 467 {
 468     if (g_event_callback.candidate_hide) {
 469         g_event_callback.candidate_hide(ic, g_event_callback.candidate_hide_user_data);
 470     }
 471 }
 472
 473 void CCoreEventCallback::on_update_lookup_table(SclCandidateTable &table)
 474 {
 475     Eina_List *string_list = NULL;
 476
 477     if (g_event_callback.lookup_table_changed) {
 478         vector<string>::iterator iter = table.candidate.begin();
 479         for (; iter != table.candidate.end(); ++iter) {
 480             string_list = eina_list_append(string_list, iter->c_str());
 481         }
 482
 483         g_event_callback.lookup_table_changed(string_list, g_event_callback.lookup_table_changed_user_data);
 484     }
 485 }
 486
 487 void CCoreEventCallback::on_process_input_device_event(sclu32 &type, sclchar *data, size_t &len, sclu32 *ret)
 488 {
 489     typedef struct {
 490         int ecore_event_id;
 491         ime_input_device_type_e device_type;
 492     } ime_device_type_conv_table;
 493
 494     ime_device_type_conv_table conv_table[] = {
 495         { ECORE_EVENT_DETENT_ROTATE , IME_INPUT_DEVICE_TYPE_ROTARY },
 496     };
 497
 498     ime_input_device_type_e device_type = IME_INPUT_DEVICE_TYPE_UNKNOWN;
 499     for (unsigned int loop = 0; loop < sizeof(conv_table) / sizeof(ime_device_type_conv_table); loop++) {
 500         if ((unsigned int)(conv_table[loop].ecore_event_id) == type) {
 501             device_type = conv_table[loop].device_type;
 502         }
 503     }
 504
 505     if (g_event_callback.process_input_device_event) {
 506         ime_device_event_s device_event;
 507         device_event.device_type = device_type;
 508         device_event.event_data = static_cast<void*>(data);
 509         void *input_data = static_cast<void*>(&device_event);
 510         void *user_data = g_event_callback.process_input_device_event_user_data;
 511
 512         g_event_callback.process_input_device_event(device_type, input_data, user_data);
 513
 514         if (ret) {
 515             *ret = 1;
 516         }
 517     } else {
 518         if (ret) {
 519             *ret = 0;
 520         }
 521     }
 522 }
 523
 524 void CCoreEventCallback::on_set_prediction_hint(const sclchar *prediction_hint)
 525 {
 526     if (g_event_callback.prediction_hint_set) {
 527         g_event_callback.prediction_hint_set(prediction_hint, g_event_callback.prediction_hint_set_user_data);
 528     }
 529 }
 530
 531 void CCoreEventCallback::on_set_mime_type(const sclchar *mime_type)
 532 {
 533     if (g_event_callback.mime_type_set) {
 534         g_event_callback.mime_type_set(mime_type, g_event_callback.mime_type_set_user_data);
 535     }
 536 }
 537
 538 void CCoreEventCallback::on_set_prediction_hint_data(const sclchar *key, const sclchar *value)
 539 {
 540     if (g_event_callback.prediction_hint_data_set) {
 541         g_event_callback.prediction_hint_data_set(key, value, g_event_callback.prediction_hint_data_set_user_data);
 542     }
 543 }
 544
 545 void CCoreEventCallback::on_set_optimization_hint(sclu32 hint)
 546 {
 547     if (g_event_callback.optimization_hint_set) {
 548         g_event_callback.optimization_hint_set((ime_optimization_hint_e)hint, g_event_callback.optimization_hint_set_user_data);
 549     }
 550 }
 551
 552 void CCoreEventCallback::on_process_key_event_with_imengine(scim::KeyEvent &key, sclu32 serial)
 553 {
 554     if (g_event_callback.process_key_event_with_imengine) {
 555         g_event_callback.process_key_event_with_imengine(key, serial, g_event_callback.process_key_event_with_imengine_user_data);
 556     }
 557 }
 558
 559 void CCoreEventCallback::on_set_autocapital_type(sclu32 type)
 560 {
 561     if (g_event_callback.autocapital_type_set) {
 562         g_event_callback.autocapital_type_set(type, g_event_callback.autocapital_type_set_user_data);
 563     }
 564 }
 565
 566 void CCoreEventCallback::on_set_prediction_allow(sclu32 prediction_allow)
 567 {
 568     if (g_event_callback.prediction_allow_set) {
 569         g_event_callback.prediction_allow_set(prediction_allow, g_event_callback.prediction_allow_set_user_data);
 570     }
 571 }
 572
 573 void CCoreEventCallback::on_trigger_property(const sclchar *property)
 574 {
 575     if (g_event_callback.trigger_property_set) {
 576         g_event_callback.trigger_property_set(property, g_event_callback.trigger_property_set_user_data);
 577     }
 578 }
 579
 580 void CCoreEventCallback::on_candidate_more_window_show(sclint ic, const sclchar *uuid)
 581 {
 582     if (g_event_callback.candidate_more_window_show) {
 583         g_event_callback.candidate_more_window_show(g_event_callback.candidate_more_window_show_user_data);
 584     }
 585 }
 586
 587 void CCoreEventCallback::on_candidate_more_window_hide(sclint ic, const sclchar *uuid)
 588 {
 589     if (g_event_callback.candidate_more_window_hide) {
 590         g_event_callback.candidate_more_window_hide(g_event_callback.candidate_more_window_hide_user_data);
 591     }
 592 }
 593
 594 void CCoreEventCallback::on_select_aux(sclint ic, const sclchar *uuid, sclint index)
 595 {
 596     if (g_event_callback.aux_select) {
 597         g_event_callback.aux_select((uint32_t)index, g_event_callback.aux_select_user_data);
 598     }
 599 }
 600
 601 void CCoreEventCallback::on_select_candidate(sclint ic, const sclchar *uuid, sclint index)
 602 {
 603     if (g_event_callback.candidate_select) {
 604         g_event_callback.candidate_select((uint32_t)index, g_event_callback.candidate_select_user_data);
 605     }
 606 }
 607
 608 void CCoreEventCallback::on_candidate_table_page_up(sclint ic, const sclchar *uuid)
 609 {
 610     if (g_event_callback.candidate_table_page_up) {
 611         g_event_callback.candidate_table_page_up(g_event_callback.candidate_table_page_up_user_data);
 612     }
 613 }
 614
 615 void CCoreEventCallback::on_candidate_table_page_down(sclint ic, const sclchar *uuid)
 616 {
 617     if (g_event_callback.candidate_table_page_down) {
 618         g_event_callback.candidate_table_page_down(g_event_callback.candidate_table_page_down_user_data);
 619     }
 620 }
 621
 622 void CCoreEventCallback::on_update_candidate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size)
 623 {
 624     if (g_event_callback.candidate_table_page_size_chaned) {
 625         g_event_callback.candidate_table_page_size_chaned((uint32_t)page_size, g_event_callback.candidate_table_page_size_chaned_user_data);
 626     }
 627 }
 628
 629 void CCoreEventCallback::on_update_candidate_item_layout(const std::vector<sclu32> item)
 630 {
 631     if (g_event_callback.candidate_item_layout_set) {
 632         g_event_callback.candidate_item_layout_set(item, g_event_callback.candidate_item_layout_set_user_data);
 633     }
 634 }
 635
 636 void CCoreEventCallback::on_update_displayed_candidate_number(sclu32 size)
 637 {
 638     if (g_event_callback.displayed_candidate_number_chaned) {
 639         g_event_callback.displayed_candidate_number_chaned(size, g_event_callback.displayed_candidate_number_chaned_user_data);
 640     }
 641 }
 642
 643 void CCoreEventCallback::on_longpress_candidate(sclu32 index)
 644 {
 645     if (g_event_callback.candidate_item_long_pressed) {
 646         g_event_callback.candidate_item_long_pressed(index, g_event_callback.candidate_item_long_pressed_user_data);
 647     }
 648 }
 649
 650 void ime_privilege_cache_init()
 651 {
 652     g_permission_allowed = false;
 653     g_checked_privilege = false;
 654 }
 655 //LCOV_EXCL_STOP
 656
 657 ime_error_e _check_privilege()
 658 {
 659     char uid[16];
 660     ime_error_e ret = IME_ERROR_NONE;
 661
 662     if (g_checked_privilege) {
 663         return g_permission_allowed ? IME_ERROR_NONE : IME_ERROR_PERMISSION_DENIED;
 664     }
 665
 666     if (inputmethod_cynara_initialize() == false) {
 667         //LCOV_EXCL_START
 668         g_permission_allowed = false;
 669         g_checked_privilege = true;
 670         LOGE("inputmethod_cynara_initialize () == false");
 671         //LCOV_EXCL_STOP
 672         return IME_ERROR_PERMISSION_DENIED;
 673     }
 674
 675     snprintf(uid, 16, "%d", getuid());
 676     if (check_privilege(uid, IME_PRIVILEGE) == false) {
 677         LOGE("check_privilege(uid, IME_PRIVILEGE) == false. uid : %s", uid); //LCOV_EXCL_LINE
 678         ret = IME_ERROR_PERMISSION_DENIED;
 679     }
 680
 681     g_permission_allowed = (ret == IME_ERROR_NONE);
 682     g_checked_privilege = true;
 683
 684     inputmethod_cynara_finish();
 685
 686     return ret;
 687 }
 688
 689 //LCOV_EXCL_START
 690 bool g_from_dotnet = false;
 691 EXPORT_API int ime_set_dotnet_flag(bool set)
 692 {
 693     ime_error_e retVal = IME_ERROR_NONE;
 694
 695     retVal = _check_privilege();
 696     if (retVal != IME_ERROR_NONE) return retVal;
 697
 698     g_from_dotnet = set;
 699
 700     return retVal;
 701 }
 702 //LCOV_EXCL_STOP
 703
 704 EXPORT_API int ime_run(ime_callback_s *basic_cb, void *user_data)
 705 {
 706     ime_error_e retVal = IME_ERROR_NONE;
 707
 708     if (g_running) {
 709         //LCOV_EXCL_START
 710         LOGE("inputmethod main loop is already running.");
 711         return IME_ERROR_OPERATION_FAILED;
 712         //LCOV_EXCL_STOP
 713     }
 714
 715     if (!basic_cb) {
 716         LOGE("basic callbacks pointer is null.");
 717         return IME_ERROR_INVALID_PARAMETER;
 718     }
 719
 720     retVal = _check_privilege();
 721     if (retVal != IME_ERROR_NONE) return retVal;
 722
 723     g_basic_callback = *basic_cb;
 724
 725     if (!g_basic_callback.create || !g_basic_callback.terminate ||
 726         !g_basic_callback.show || !g_basic_callback.hide) {
 727         LOGE("mandatory callback functions are not set");
 728         memset(&g_basic_callback, 0, sizeof(ime_callback_s));
 729         memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
 730         return IME_ERROR_NO_CALLBACK_FUNCTION;
 731     }
 732
 733     //LCOV_EXCL_START
 734     g_user_data = user_data;
 735     g_running = true;
 736
 737     if (g_from_dotnet) {
 738         LOGD("ime_run is called from dotnet");
 739         return IME_ERROR_NONE;
 740     }
 741
 742     try {
 743         g_core.run();
 744     } catch (...) {
 745         LOGW("exception is thrown from g_core.run()\n");
 746     }
 747
 748     memset(&g_basic_callback, 0, sizeof(ime_callback_s));
 749     memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
 750     g_user_data = NULL;
 751     g_running = false;
 752
 753     return IME_ERROR_NONE;
 754     //LCOV_EXCL_STOP
 755 }
 756
 757 EXPORT_API int ime_event_set_focus_in_cb(ime_focus_in_cb callback_func, void *user_data)
 758 {
 759     ime_error_e retVal = IME_ERROR_NONE;
 760
 761     if (!callback_func) {
 762         LOGW("IME_ERROR_INVALID_PARAMETER");
 763         return IME_ERROR_INVALID_PARAMETER;
 764     }
 765
 766     retVal = _check_privilege();
 767     if (retVal != IME_ERROR_NONE) return retVal;
 768
 769     g_event_callback.focus_in = callback_func;
 770     g_event_callback.focus_in_user_data = user_data;
 771
 772     return IME_ERROR_NONE;
 773 }
 774
 775 EXPORT_API int ime_event_set_focus_out_cb(ime_focus_out_cb callback_func, void *user_data)
 776 {
 777     ime_error_e retVal = IME_ERROR_NONE;
 778
 779     if (!callback_func) {
 780         LOGW("IME_ERROR_INVALID_PARAMETER");
 781         return IME_ERROR_INVALID_PARAMETER;
 782     }
 783
 784     retVal = _check_privilege();
 785     if (retVal != IME_ERROR_NONE) return retVal;
 786
 787     g_event_callback.focus_out = callback_func;
 788     g_event_callback.focus_out_user_data = user_data;
 789
 790     return IME_ERROR_NONE;
 791 }
 792
 793 EXPORT_API int ime_event_set_surrounding_text_updated_cb(ime_surrounding_text_updated_cb callback_func, void *user_data)
 794 {
 795     ime_error_e retVal = IME_ERROR_NONE;
 796
 797     if (!callback_func) {
 798         LOGW("IME_ERROR_INVALID_PARAMETER");
 799         return IME_ERROR_INVALID_PARAMETER;
 800     }
 801
 802     retVal = _check_privilege();
 803     if (retVal != IME_ERROR_NONE) return retVal;
 804
 805     g_event_callback.surrounding_text_updated = callback_func;
 806     g_event_callback.surrounding_text_updated_user_data = user_data;
 807
 808     return IME_ERROR_NONE;
 809 }
 810
 811 EXPORT_API int ime_event_set_input_context_reset_cb(ime_input_context_reset_cb callback_func, void *user_data)
 812 {
 813     ime_error_e retVal = IME_ERROR_NONE;
 814
 815     if (!callback_func) {
 816         LOGW("IME_ERROR_INVALID_PARAMETER");
 817         return IME_ERROR_INVALID_PARAMETER;
 818     }
 819
 820     retVal = _check_privilege();
 821     if (retVal != IME_ERROR_NONE) return retVal;
 822
 823     g_event_callback.input_context_reset = callback_func;
 824     g_event_callback.input_context_reset_user_data = user_data;
 825
 826     return IME_ERROR_NONE;
 827 }
 828
 829 EXPORT_API int ime_event_set_cursor_position_updated_cb(ime_cursor_position_updated_cb callback_func, void *user_data)
 830 {
 831     ime_error_e retVal = IME_ERROR_NONE;
 832
 833     if (!callback_func) {
 834         LOGW("IME_ERROR_INVALID_PARAMETER");
 835         return IME_ERROR_INVALID_PARAMETER;
 836     }
 837
 838     retVal = _check_privilege();
 839     if (retVal != IME_ERROR_NONE) return retVal;
 840
 841     g_event_callback.cursor_position_updated = callback_func;
 842     g_event_callback.cursor_position_updated_user_data = user_data;
 843
 844     return IME_ERROR_NONE;
 845 }
 846
 847 EXPORT_API int ime_event_set_language_requested_cb(ime_language_requested_cb callback_func, void *user_data)
 848 {
 849     ime_error_e retVal = IME_ERROR_NONE;
 850
 851     if (!callback_func) {
 852         LOGW("IME_ERROR_INVALID_PARAMETER");
 853         return IME_ERROR_INVALID_PARAMETER;
 854     }
 855
 856     retVal = _check_privilege();
 857     if (retVal != IME_ERROR_NONE) return retVal;
 858
 859     g_event_callback.language_requested = callback_func;
 860     g_event_callback.language_requested_user_data = user_data;
 861
 862     return IME_ERROR_NONE;
 863 }
 864
 865 EXPORT_API int ime_event_set_language_set_cb(ime_language_set_cb callback_func, void *user_data)
 866 {
 867     ime_error_e retVal = IME_ERROR_NONE;
 868
 869     if (!callback_func) {
 870         LOGW("IME_ERROR_INVALID_PARAMETER");
 871         return IME_ERROR_INVALID_PARAMETER;
 872     }
 873
 874     retVal = _check_privilege();
 875     if (retVal != IME_ERROR_NONE) return retVal;
 876
 877     g_event_callback.language_set = callback_func;
 878     g_event_callback.language_set_user_data = user_data;
 879
 880     return IME_ERROR_NONE;
 881 }
 882
 883 EXPORT_API int ime_event_set_imdata_set_cb(ime_imdata_set_cb callback_func, void *user_data)
 884 {
 885     ime_error_e retVal = IME_ERROR_NONE;
 886
 887     if (!callback_func) {
 888         LOGW("IME_ERROR_INVALID_PARAMETER");
 889         return IME_ERROR_INVALID_PARAMETER;
 890     }
 891
 892     retVal = _check_privilege();
 893     if (retVal != IME_ERROR_NONE) return retVal;
 894
 895     g_event_callback.imdata_set = callback_func;
 896     g_event_callback.imdata_set_user_data = user_data;
 897
 898     return IME_ERROR_NONE;
 899 }
 900
 901 EXPORT_API int ime_event_set_imdata_requested_cb(ime_imdata_requested_cb callback_func, void *user_data)
 902 {
 903     ime_error_e retVal = IME_ERROR_NONE;
 904
 905     if (!callback_func) {
 906         LOGW("IME_ERROR_INVALID_PARAMETER");
 907         return IME_ERROR_INVALID_PARAMETER;
 908     }
 909
 910     retVal = _check_privilege();
 911     if (retVal != IME_ERROR_NONE) return retVal;
 912
 913     g_event_callback.imdata_requested = callback_func;
 914     g_event_callback.imdata_requested_user_data = user_data;
 915
 916     return IME_ERROR_NONE;
 917 }
 918
 919 EXPORT_API int ime_event_set_layout_set_cb(ime_layout_set_cb callback_func, void *user_data)
 920 {
 921     ime_error_e retVal = IME_ERROR_NONE;
 922
 923     if (!callback_func) {
 924         LOGW("IME_ERROR_INVALID_PARAMETER");
 925         return IME_ERROR_INVALID_PARAMETER;
 926     }
 927
 928     retVal = _check_privilege();
 929     if (retVal != IME_ERROR_NONE) return retVal;
 930
 931     g_event_callback.layout_set = callback_func;
 932     g_event_callback.layout_set_user_data = user_data;
 933
 934     return IME_ERROR_NONE;
 935 }
 936
 937 EXPORT_API int ime_event_set_return_key_type_set_cb(ime_return_key_type_set_cb callback_func, void *user_data)
 938 {
 939     ime_error_e retVal = IME_ERROR_NONE;
 940
 941     if (!callback_func) {
 942         LOGW("IME_ERROR_INVALID_PARAMETER");
 943         return IME_ERROR_INVALID_PARAMETER;
 944     }
 945
 946     retVal = _check_privilege();
 947     if (retVal != IME_ERROR_NONE) return retVal;
 948
 949     g_event_callback.return_key_type_set = callback_func;
 950     g_event_callback.return_key_type_set_user_data = user_data;
 951
 952     return IME_ERROR_NONE;
 953 }
 954
 955 EXPORT_API int ime_event_set_return_key_state_set_cb(ime_return_key_state_set_cb callback_func, void *user_data)
 956 {
 957     ime_error_e retVal = IME_ERROR_NONE;
 958
 959     if (!callback_func) {
 960         LOGW("IME_ERROR_INVALID_PARAMETER");
 961         return IME_ERROR_INVALID_PARAMETER;
 962     }
 963
 964     retVal = _check_privilege();
 965     if (retVal != IME_ERROR_NONE) return retVal;
 966
 967     g_event_callback.return_key_state_set = callback_func;
 968     g_event_callback.return_key_state_set_user_data = user_data;
 969
 970     return IME_ERROR_NONE;
 971 }
 972
 973 EXPORT_API int ime_event_set_geometry_requested_cb(ime_geometry_requested_cb callback_func, void *user_data)
 974 {
 975     ime_error_e retVal = IME_ERROR_NONE;
 976
 977     if (!callback_func) {
 978         LOGW("IME_ERROR_INVALID_PARAMETER");
 979         return IME_ERROR_INVALID_PARAMETER;
 980     }
 981
 982     retVal = _check_privilege();
 983     if (retVal != IME_ERROR_NONE) return retVal;
 984
 985     g_event_callback.geometry_requested = callback_func;
 986     g_event_callback.geometry_requested_user_data = user_data;
 987
 988     return IME_ERROR_NONE;
 989 }
 990
 991 EXPORT_API int ime_event_set_process_key_event_cb(ime_process_key_event_cb callback_func, void *user_data)
 992 {
 993     ime_error_e retVal = IME_ERROR_NONE;
 994
 995     if (!callback_func) {
 996         LOGW("IME_ERROR_INVALID_PARAMETER");
 997         return IME_ERROR_INVALID_PARAMETER;
 998     }
 999
1000     retVal = _check_privilege();
1001     if (retVal != IME_ERROR_NONE) return retVal;
1002
1003     g_event_callback.process_key_event = callback_func;
1004     g_event_callback.process_key_event_user_data = user_data;
1005
1006     return IME_ERROR_NONE;
1007 }
1008
1009 EXPORT_API int ime_event_set_process_key_event_with_keycode_cb(ime_process_key_event_with_keycode_cb callback_func, void *user_data)
1010 {
1011     ime_error_e retVal = IME_ERROR_NONE;
1012
1013     if (!callback_func) {
1014         LOGW("IME_ERROR_INVALID_PARAMETER");
1015         return IME_ERROR_INVALID_PARAMETER;
1016     }
1017
1018     retVal = _check_privilege();
1019     if (retVal != IME_ERROR_NONE) return retVal;
1020
1021     g_event_callback.process_key_event_with_keycode = callback_func;
1022     g_event_callback.process_key_event_with_keycode_user_data = user_data;
1023
1024     return IME_ERROR_NONE;
1025 }
1026
1027 EXPORT_API int ime_event_set_display_language_changed_cb(ime_display_language_changed_cb callback_func, void *user_data)
1028 {
1029     ime_error_e retVal = IME_ERROR_NONE;
1030
1031     if (!callback_func) {
1032         LOGW("IME_ERROR_INVALID_PARAMETER");
1033         return IME_ERROR_INVALID_PARAMETER;
1034     }
1035
1036     retVal = _check_privilege();
1037     if (retVal != IME_ERROR_NONE) return retVal;
1038
1039     g_event_callback.display_language_changed = callback_func;
1040     g_event_callback.display_language_changed_user_data = user_data;
1041
1042     return IME_ERROR_NONE;
1043 }
1044
1045 EXPORT_API int ime_event_set_rotation_degree_changed_cb(ime_rotation_degree_changed_cb callback_func, void *user_data)
1046 {
1047     ime_error_e retVal = IME_ERROR_NONE;
1048
1049     if (!callback_func) {
1050         LOGW("IME_ERROR_INVALID_PARAMETER");
1051         return IME_ERROR_INVALID_PARAMETER;
1052     }
1053
1054     retVal = _check_privilege();
1055     if (retVal != IME_ERROR_NONE) return retVal;
1056
1057     g_event_callback.rotation_degree_changed = callback_func;
1058     g_event_callback.rotation_degree_changed_user_data = user_data;
1059
1060     return IME_ERROR_NONE;
1061 }
1062
1063 EXPORT_API int ime_event_set_accessibility_state_changed_cb(ime_accessibility_state_changed_cb callback_func, void *user_data)
1064 {
1065     ime_error_e retVal = IME_ERROR_NONE;
1066
1067     if (!callback_func) {
1068         LOGW("IME_ERROR_INVALID_PARAMETER");
1069         return IME_ERROR_INVALID_PARAMETER;
1070     }
1071
1072     retVal = _check_privilege();
1073     if (retVal != IME_ERROR_NONE) return retVal;
1074
1075     g_event_callback.accessibility_state_changed = callback_func;
1076     g_event_callback.accessibility_state_changed_user_data = user_data;
1077
1078     return IME_ERROR_NONE;
1079 }
1080
1081 EXPORT_API int ime_event_set_option_window_created_cb(ime_option_window_created_cb callback_func, void *user_data)
1082 {
1083     ime_error_e retVal = IME_ERROR_NONE;
1084
1085     if (!callback_func) {
1086         LOGW("IME_ERROR_INVALID_PARAMETER");
1087         return IME_ERROR_INVALID_PARAMETER;
1088     }
1089
1090     retVal = _check_privilege();
1091     if (retVal != IME_ERROR_NONE) return retVal;
1092
1093     g_event_callback.option_window_created = callback_func;
1094     g_event_callback.option_window_created_user_data = user_data;
1095
1096     return IME_ERROR_NONE;
1097 }
1098
1099 EXPORT_API int ime_event_set_option_window_destroyed_cb(ime_option_window_destroyed_cb callback_func, void *user_data)
1100 {
1101     ime_error_e retVal = IME_ERROR_NONE;
1102
1103     if (!callback_func) {
1104         LOGW("IME_ERROR_INVALID_PARAMETER");
1105         return IME_ERROR_INVALID_PARAMETER;
1106     }
1107
1108     retVal = _check_privilege();
1109     if (retVal != IME_ERROR_NONE) return retVal;
1110
1111     g_event_callback.option_window_destroyed = callback_func;
1112     g_event_callback.option_window_destroyed_user_data = user_data;
1113
1114     return IME_ERROR_NONE;
1115 }
1116
1117 //LCOV_EXCL_START
1118 EXPORT_API int ime_event_set_caps_mode_changed_cb(ime_caps_mode_changed_cb callback_func, void *user_data)
1119 {
1120     ime_error_e retVal = IME_ERROR_NONE;
1121
1122     if (!callback_func) {
1123         LOGW("IME_ERROR_INVALID_PARAMETER");
1124         return IME_ERROR_INVALID_PARAMETER;
1125     }
1126
1127     retVal = _check_privilege();
1128     if (retVal != IME_ERROR_NONE) return retVal;
1129
1130     g_event_callback.caps_mode_changed = callback_func;
1131     g_event_callback.caps_mode_changed_user_data = user_data;
1132
1133     return IME_ERROR_NONE;
1134 }
1135
1136 EXPORT_API int ime_event_set_candidate_show_cb(ime_candidate_show_cb callback_func, void *user_data)
1137 {
1138     ime_error_e retVal = IME_ERROR_NONE;
1139
1140     if (!callback_func) {
1141         LOGW("IME_ERROR_INVALID_PARAMETER");
1142         return IME_ERROR_INVALID_PARAMETER;
1143     }
1144
1145     retVal = _check_privilege();
1146     if (retVal != IME_ERROR_NONE) return retVal;
1147
1148     g_event_callback.candidate_show = callback_func;
1149     g_event_callback.candidate_show_user_data = user_data;
1150
1151     return IME_ERROR_NONE;
1152 }
1153
1154 EXPORT_API int ime_event_set_candidate_hide_cb(ime_candidate_hide_cb callback_func, void *user_data)
1155 {
1156     ime_error_e retVal = IME_ERROR_NONE;
1157
1158     if (!callback_func) {
1159         LOGW("IME_ERROR_INVALID_PARAMETER");
1160         return IME_ERROR_INVALID_PARAMETER;
1161     }
1162
1163     retVal = _check_privilege();
1164     if (retVal != IME_ERROR_NONE) return retVal;
1165
1166     g_event_callback.candidate_hide = callback_func;
1167     g_event_callback.candidate_hide_user_data = user_data;
1168
1169     return IME_ERROR_NONE;
1170 }
1171
1172 EXPORT_API int ime_event_set_lookup_table_changed_cb(ime_lookup_table_changed_cb callback_func, void *user_data)
1173 {
1174     ime_error_e retVal = IME_ERROR_NONE;
1175
1176     if (!callback_func) {
1177         LOGW("IME_ERROR_INVALID_PARAMETER");
1178         return IME_ERROR_INVALID_PARAMETER;
1179     }
1180
1181     retVal = _check_privilege();
1182     if (retVal != IME_ERROR_NONE) return retVal;
1183
1184     g_event_callback.lookup_table_changed = callback_func;
1185     g_event_callback.lookup_table_changed_user_data = user_data;
1186
1187     return IME_ERROR_NONE;
1188 }
1189 //LCOV_EXCL_STOP
1190
1191 EXPORT_API int ime_send_key_event(ime_key_code_e keycode, ime_key_mask_e keymask, bool forward_key)
1192 {
1193     ime_error_e retVal = IME_ERROR_NONE;
1194
1195     if (!g_running) {
1196         LOGW("IME_ERROR_NOT_RUNNING");
1197         return IME_ERROR_NOT_RUNNING;
1198     }
1199
1200     //LCOV_EXCL_START
1201     retVal = _check_privilege();
1202     if (retVal != IME_ERROR_NONE) return retVal;
1203
1204     if (forward_key)
1205         g_core.forward_key_event(-1, NULL, (sclu32)keycode, (sclu16)keymask);
1206     else
1207         g_core.send_key_event(-1, NULL, (sclu32)keycode, (sclu16)keymask);
1208     //LCOV_EXCL_STOP
1209
1210     return IME_ERROR_NONE;
1211 }
1212
1213 EXPORT_API int ime_commit_string(const char *str)
1214 {
1215     ime_error_e retVal = IME_ERROR_NONE;
1216
1217     if (!str) {
1218         LOGW("IME_ERROR_INVALID_PARAMETER");
1219         return IME_ERROR_INVALID_PARAMETER;
1220     }
1221
1222     if (!g_running) {
1223         LOGW("IME_ERROR_NOT_RUNNING");
1224         return IME_ERROR_NOT_RUNNING;
1225     }
1226
1227     //LCOV_EXCL_START
1228     retVal = _check_privilege();
1229     if (retVal != IME_ERROR_NONE) return retVal;
1230
1231     SECURE_LOGI("commit string : %s", str);
1232     g_core.commit_string(-1, NULL, str);
1233
1234     return IME_ERROR_NONE;
1235     //LCOV_EXCL_STOP
1236 }
1237
1238 EXPORT_API int ime_show_preedit_string(void)
1239 {
1240     ime_error_e retVal = IME_ERROR_NONE;
1241
1242     if (!g_running) {
1243         LOGW("IME_ERROR_NOT_RUNNING");
1244         return IME_ERROR_NOT_RUNNING;
1245     }
1246
1247     //LCOV_EXCL_START
1248     retVal = _check_privilege();
1249     if (retVal != IME_ERROR_NONE) return retVal;
1250
1251     g_core.show_preedit_string(-1, NULL);
1252
1253     return IME_ERROR_NONE;
1254     //LCOV_EXCL_STOP
1255 }
1256
1257 EXPORT_API int ime_hide_preedit_string(void)
1258 {
1259     ime_error_e retVal = IME_ERROR_NONE;
1260
1261     if (!g_running) {
1262         LOGW("IME_ERROR_NOT_RUNNING");
1263         return IME_ERROR_NOT_RUNNING;
1264     }
1265
1266     //LCOV_EXCL_START
1267     retVal = _check_privilege();
1268     if (retVal != IME_ERROR_NONE) return retVal;
1269
1270     g_core.hide_preedit_string(-1, NULL);
1271
1272     return IME_ERROR_NONE;
1273     //LCOV_EXCL_STOP
1274 }
1275
1276 EXPORT_API int ime_update_preedit_string(const char *str, Eina_List *attrs)
1277 {
1278     ime_error_e retVal = IME_ERROR_NONE;
1279
1280     if (!str) {
1281         LOGW("IME_ERROR_INVALID_PARAMETER");
1282         return IME_ERROR_INVALID_PARAMETER;
1283     }
1284
1285     if (!g_running) {
1286         LOGW("IME_ERROR_NOT_RUNNING");
1287         return IME_ERROR_NOT_RUNNING;
1288     }
1289
1290     //LCOV_EXCL_START
1291     retVal = _check_privilege();
1292     if (retVal != IME_ERROR_NONE) return retVal;
1293
1294     scim::AttributeList attrv;
1295     void *data = NULL;
1296     ime_preedit_attribute *attr = NULL;
1297
1298     if (attrs) {
1299         EINA_LIST_FREE(attrs, data) {
1300             attr = (ime_preedit_attribute *)data;
1301             if (attr) {
1302                 attrv.push_back(scim::Attribute(attr->start, attr->length, (scim::AttributeType)attr->type, attr->value));
1303                 free(attr);
1304             }
1305         }
1306     }
1307
1308     SECURE_LOGI("preedit string : '%s'", str);
1309     g_core.update_preedit_string(-1, NULL, str, attrv);
1310
1311     return IME_ERROR_NONE;
1312     //LCOV_EXCL_STOP
1313 }
1314
1315 EXPORT_API int ime_request_surrounding_text(int maxlen_before, int maxlen_after)
1316 {
1317     ime_error_e retVal = IME_ERROR_NONE;
1318
1319     if (!g_event_callback.surrounding_text_updated) {
1320         LOGW("IME_ERROR_NO_CALLBACK_FUNCTION");
1321         return IME_ERROR_NO_CALLBACK_FUNCTION;
1322     }
1323
1324     if (!g_running) {
1325         LOGW("IME_ERROR_NOT_RUNNING");
1326         return IME_ERROR_NOT_RUNNING;
1327     }
1328
1329     //LCOV_EXCL_START
1330     retVal = _check_privilege();
1331     if (retVal != IME_ERROR_NONE) return retVal;
1332
1333     g_core.get_surrounding_text(NULL, maxlen_before, maxlen_after);
1334
1335     return IME_ERROR_NONE;
1336     //LCOV_EXCL_STOP
1337 }
1338
1339 EXPORT_API int ime_delete_surrounding_text(int offset, int len)
1340 {
1341     ime_error_e retVal = IME_ERROR_NONE;
1342
1343     if (len <= 0) {
1344         LOGW("IME_ERROR_INVALID_PARAMETER");
1345         return IME_ERROR_INVALID_PARAMETER;
1346     }
1347
1348     if (!g_running) {
1349         LOGW("IME_ERROR_NOT_RUNNING");
1350         return IME_ERROR_NOT_RUNNING;
1351     }
1352
1353     //LCOV_EXCL_START
1354     retVal = _check_privilege();
1355     if (retVal != IME_ERROR_NONE) return retVal;
1356
1357     LOGI("offset: %d, len : %d", offset, len);
1358     g_core.delete_surrounding_text(offset, len);
1359
1360     return IME_ERROR_NONE;
1361     //LCOV_EXCL_STOP
1362 }
1363
1364 EXPORT_API int ime_get_surrounding_text(int maxlen_before, int maxlen_after, char **text, int *cursor_pos)
1365 {
1366     ime_error_e retVal = IME_ERROR_NONE;
1367
1368     if (!text || !cursor_pos) {
1369         LOGW("IME_ERROR_INVALID_PARAMETER");
1370         return IME_ERROR_INVALID_PARAMETER;
1371     }
1372
1373     if (!g_running) {
1374         LOGW("IME_ERROR_NOT_RUNNING");
1375         return IME_ERROR_NOT_RUNNING;
1376     }
1377
1378     //LCOV_EXCL_START
1379     retVal = _check_privilege();
1380     if (retVal != IME_ERROR_NONE) return retVal;
1381
1382     int cursor = 0;
1383
1384     int ret = g_core.get_surrounding_text(maxlen_before, maxlen_after, text, cursor);
1385     if (ret == -1) {
1386         LOGW("IME_ERROR_OUR_OF_MEMORY");
1387         return IME_ERROR_OUT_OF_MEMORY;
1388     }
1389
1390     if (cursor_pos)
1391         *cursor_pos = cursor;
1392
1393     return IME_ERROR_NONE;
1394     //LCOV_EXCL_STOP
1395 }
1396
1397 EXPORT_API int ime_set_selection(int start, int end)
1398 {
1399     ime_error_e retVal = IME_ERROR_NONE;
1400
1401     if (start < 0) {
1402         LOGW("IME_ERROR_INVALID_PARAMETER");
1403         return IME_ERROR_INVALID_PARAMETER;
1404     }
1405
1406     if (!g_running) {
1407         LOGW("IME_ERROR_NOT_RUNNING");
1408         return IME_ERROR_NOT_RUNNING;
1409     }
1410
1411     //LCOV_EXCL_START
1412     retVal = _check_privilege();
1413     if (retVal != IME_ERROR_NONE) return retVal;
1414
1415     LOGI("start: %d, end : %d", start, end);
1416     g_core.set_selection(start, end);
1417
1418     return IME_ERROR_NONE;
1419     //LCOV_EXCL_STOP
1420 }
1421
1422 EXPORT_API int ime_get_selected_text(char **text)
1423 {
1424     ime_error_e retVal = IME_ERROR_NONE;
1425
1426     if (!text) {
1427         LOGW("IME_ERROR_INVALID_PARAMETER");
1428         return IME_ERROR_INVALID_PARAMETER;
1429     }
1430
1431     if (!g_running) {
1432         LOGW("IME_ERROR_NOT_RUNNING");
1433         return IME_ERROR_NOT_RUNNING;
1434     }
1435
1436     //LCOV_EXCL_START
1437     retVal = _check_privilege();
1438     if (retVal != IME_ERROR_NONE) return retVal;
1439
1440     g_core.get_selection_text(text);
1441
1442     return IME_ERROR_NONE;
1443     //LCOV_EXCL_STOP
1444 }
1445
1446 EXPORT_API Evas_Object* ime_get_main_window(void)
1447 {
1448     ime_error_e retVal = IME_ERROR_NONE;
1449
1450     Evas_Object *win = NULL;
1451
1452     retVal = _check_privilege();
1453     if (retVal != IME_ERROR_NONE) {
1454         //LCOV_EXCL_START
1455         LOGE("_check_privilege returned %d.", retVal);
1456         set_last_result(retVal);
1457         return NULL;
1458         //LCOV_EXCL_STOP
1459     }
1460
1461     if (!g_running) {
1462         set_last_result(IME_ERROR_NOT_RUNNING);
1463         LOGW("IME_ERROR_NOT_RUNNING");
1464         return NULL;
1465     }
1466
1467     //LCOV_EXCL_START
1468     win = static_cast<Evas_Object*>(g_core.get_main_window());
1469     if (win) {
1470         set_last_result(IME_ERROR_NONE);
1471     } else {
1472         set_last_result(IME_ERROR_OPERATION_FAILED);
1473         LOGW("IME_ERROR_OPERATION_FAILED");
1474     }
1475
1476     return win;
1477     //LCOV_EXCL_STOP
1478 }
1479
1480 EXPORT_API int ime_set_size(int portrait_width, int portrait_height, int landscape_width, int landscape_height)
1481 {
1482     ime_error_e retVal = IME_ERROR_NONE;
1483
1484     SclSize portrait_size, landscape_size;
1485
1486     if (portrait_width < 1 || portrait_height < 1 || landscape_width < 1 || landscape_height < 1) {
1487         LOGW("IME_ERROR_INVALID_PARAMETER");
1488         return IME_ERROR_INVALID_PARAMETER;
1489     }
1490
1491     if (!g_running) {
1492         LOGW("IME_ERROR_NOT_RUNNING");
1493         return IME_ERROR_NOT_RUNNING;
1494     }
1495
1496     //LCOV_EXCL_START
1497     retVal = _check_privilege();
1498     if (retVal != IME_ERROR_NONE) return retVal;
1499
1500     portrait_size.width = portrait_width;
1501     portrait_size.height = portrait_height;
1502
1503     landscape_size.width = landscape_width;
1504     landscape_size.height = landscape_height;
1505
1506     g_core.set_keyboard_size_hints(portrait_size, landscape_size);
1507
1508     return IME_ERROR_NONE;
1509     //LCOV_EXCL_STOP
1510 }
1511
1512 EXPORT_API int ime_create_option_window(void)
1513 {
1514     ime_error_e retVal = IME_ERROR_NONE;
1515
1516     if (!g_event_callback.option_window_created || !g_event_callback.option_window_destroyed) {
1517         LOGW("ime_create_option_window_cb() and ime_destroy_option_window_cb() callback functions are not set.");
1518         return IME_ERROR_NO_CALLBACK_FUNCTION;
1519     }
1520
1521     if (!g_running) {
1522         LOGW("IME_ERROR_NOT_RUNNING");
1523         return IME_ERROR_NOT_RUNNING;
1524     }
1525
1526     //LCOV_EXCL_START
1527     retVal = _check_privilege();
1528     if (retVal != IME_ERROR_NONE) return retVal;
1529
1530     if (g_core.create_option_window()) {
1531         return IME_ERROR_NONE;
1532     } else {
1533         LOGW("IME_ERROR_OPERATION_FAILED");
1534         return IME_ERROR_OPERATION_FAILED;
1535     }
1536     //LCOV_EXCL_STOP
1537 }
1538
1539 EXPORT_API int ime_destroy_option_window(Evas_Object *window)
1540 {
1541     ime_error_e retVal = IME_ERROR_NONE;
1542
1543     if (!g_event_callback.option_window_created || !g_event_callback.option_window_destroyed) {
1544         LOGW("ime_create_option_window_cb() and ime_destroy_option_window_cb() callback functions are not set.");
1545         return IME_ERROR_NO_CALLBACK_FUNCTION;
1546     }
1547
1548     if (!window) {
1549         LOGW("Window pointer is null.");
1550         return IME_ERROR_INVALID_PARAMETER;
1551     }
1552
1553     if (!g_running) {
1554         LOGW("IME_ERROR_NOT_RUNNING");
1555         return IME_ERROR_NOT_RUNNING;
1556     }
1557
1558     //LCOV_EXCL_START
1559     retVal = _check_privilege();
1560     if (retVal != IME_ERROR_NONE) return retVal;
1561
1562     g_core.destroy_option_window(window);
1563
1564     return IME_ERROR_NONE;
1565     //LCOV_EXCL_STOP
1566 }
1567
1568 //LCOV_EXCL_START
1569 EXPORT_API int ime_set_imengine(const char *engine_id)
1570 {
1571     ime_error_e retVal = IME_ERROR_NONE;
1572
1573     if (!engine_id) {
1574         LOGW("IME_ERROR_INVALID_PARAMETER");
1575         return IME_ERROR_INVALID_PARAMETER;
1576     }
1577
1578     retVal = _check_privilege();
1579     if (retVal != IME_ERROR_NONE) return retVal;
1580
1581     g_core.set_keyboard_ise_by_uuid(engine_id);
1582
1583     return IME_ERROR_NONE;
1584 }
1585
1586 EXPORT_API int ime_flush_imengine(void)
1587 {
1588     ime_error_e retVal = IME_ERROR_NONE;
1589
1590     if (!g_running) {
1591         LOGW("IME_ERROR_NOT_RUNNING");
1592         return IME_ERROR_NOT_RUNNING;
1593     }
1594
1595     retVal = _check_privilege();
1596     if (retVal != IME_ERROR_NONE) return retVal;
1597
1598     g_core.flush_keyboard_ise();
1599
1600     return IME_ERROR_NONE;
1601 }
1602
1603 EXPORT_API int ime_send_imengine_event(int command, unsigned int value)
1604 {
1605     ime_error_e retVal = IME_ERROR_NONE;
1606
1607     if (!g_running) {
1608         LOGW("IME_ERROR_NOT_RUNNING");
1609         return IME_ERROR_NOT_RUNNING;
1610     }
1611
1612     retVal = _check_privilege();
1613     if (retVal != IME_ERROR_NONE) return retVal;
1614
1615     g_core.send_imengine_event(-1, NULL, command, value);
1616
1617     return IME_ERROR_NONE;
1618 }
1619
1620 EXPORT_API int ime_reset_imengine(void)
1621 {
1622     ime_error_e retVal = IME_ERROR_NONE;
1623
1624     if (!g_running) {
1625         LOGW("IME_ERROR_NOT_RUNNING");
1626         return IME_ERROR_NOT_RUNNING;
1627     }
1628
1629     retVal = _check_privilege();
1630     if (retVal != IME_ERROR_NONE) return retVal;
1631
1632     g_core.reset_keyboard_ise();
1633
1634     return IME_ERROR_NONE;
1635 }
1636
1637 EXPORT_API int ime_update_input_context(unsigned int type, unsigned int value)
1638 {
1639     ime_error_e retVal = IME_ERROR_NONE;
1640
1641     if (!g_running) {
1642         LOGW("IME_ERROR_NOT_RUNNING");
1643         return IME_ERROR_NOT_RUNNING;
1644     }
1645
1646     retVal = _check_privilege();
1647     if (retVal != IME_ERROR_NONE) return retVal;
1648
1649     g_core.update_input_context(type, value);
1650
1651     return IME_ERROR_NONE;
1652 }
1653 //LCOV_EXCL_STOP
1654
1655 EXPORT_API int ime_request_hide(void)
1656 {
1657     ime_error_e retVal = IME_ERROR_NONE;
1658
1659     if (!g_running) {
1660         LOGW("IME_ERROR_NOT_RUNNING");
1661         return IME_ERROR_NOT_RUNNING;
1662     }
1663
1664     //LCOV_EXCL_START
1665     retVal = _check_privilege();
1666     if (retVal != IME_ERROR_NONE) return retVal;
1667
1668     g_core.request_ise_hide();
1669
1670     return IME_ERROR_NONE;
1671     //LCOV_EXCL_STOP
1672 }
1673
1674 //LCOV_EXCL_START
1675 EXPORT_API int ime_initialize(void)
1676 {
1677     ime_error_e retVal = IME_ERROR_NONE;
1678
1679     retVal = _check_privilege();
1680     if (retVal != IME_ERROR_NONE) return retVal;
1681
1682     g_core.init();
1683     g_running = false;
1684
1685     return retVal;
1686 }
1687
1688 EXPORT_API int ime_prepare(void)
1689 {
1690     ime_error_e retVal = IME_ERROR_NONE;
1691
1692     if (g_running) {
1693         LOGE("inputmethod main loop is already running.");
1694         return IME_ERROR_OPERATION_FAILED;
1695     }
1696
1697     retVal = _check_privilege();
1698     if (retVal != IME_ERROR_NONE) return retVal;
1699
1700     g_core.prepare();
1701
1702     g_running = true;
1703
1704     return retVal;
1705 }
1706
1707 EXPORT_API int ime_finalize(void)
1708 {
1709     ime_error_e retVal = IME_ERROR_NONE;
1710
1711     retVal = _check_privilege();
1712     if (retVal != IME_ERROR_NONE) return retVal;
1713
1714     g_core.fini();
1715     g_running = false;
1716     memset(&g_basic_callback, 0, sizeof(ime_callback_s));
1717     memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
1718     g_user_data = NULL;
1719
1720     return retVal;
1721 }
1722
1723 EXPORT_API int ime_select_candidate(unsigned int index)
1724 {
1725     ime_error_e retVal = IME_ERROR_NONE;
1726
1727     if (!g_running) {
1728         LOGW("IME_ERROR_NOT_RUNNING");
1729         return IME_ERROR_NOT_RUNNING;
1730     }
1731
1732     retVal = _check_privilege();
1733     if (retVal != IME_ERROR_NONE) return retVal;
1734
1735     g_core.select_candidate(index);
1736
1737     return IME_ERROR_NONE;
1738 }
1739 //LCOV_EXCL_STOP
1740
1741 EXPORT_API int ime_send_private_command(const char *command)
1742 {
1743     ime_error_e retVal = IME_ERROR_NONE;
1744
1745     if (!command) {
1746         LOGW("IME_ERROR_INVALID_PARAMETER");
1747         return IME_ERROR_INVALID_PARAMETER;
1748     }
1749
1750     if (!g_running) {
1751         LOGW("IME_ERROR_NOT_RUNNING");
1752         return IME_ERROR_NOT_RUNNING;
1753     }
1754
1755     //LCOV_EXCL_START
1756     retVal = _check_privilege();
1757     if (retVal != IME_ERROR_NONE) return retVal;
1758
1759     g_core.send_private_command(command);
1760
1761     return IME_ERROR_NONE;
1762     //LCOV_EXCL_STOP
1763 }
1764
1765 EXPORT_API int ime_commit_content(const char *content, const char *description, const char *mime_type)
1766 {
1767     ime_error_e retVal = IME_ERROR_NONE;
1768
1769     if (!content || !description || !mime_type) {
1770         LOGW("IME_ERROR_INVALID_PARAMETER");
1771         return IME_ERROR_INVALID_PARAMETER;
1772     }
1773
1774     retVal = _check_privilege();
1775     if (retVal != IME_ERROR_NONE) return retVal;
1776
1777     if (!g_running) {
1778         LOGW("IME_ERROR_NOT_RUNNING");
1779         return IME_ERROR_NOT_RUNNING;
1780     }
1781
1782     //LCOV_EXCL_START
1783     LOGI("content : '%s', description : '%s', mime_type : '%s'", content, description, mime_type);
1784     g_core.commit_content(content, description, mime_type);
1785
1786     return IME_ERROR_NONE;
1787     //LCOV_EXCL_STOP
1788 }
1789
1790 EXPORT_API int ime_context_get_layout(ime_context_h context, Ecore_IMF_Input_Panel_Layout *layout)
1791 {
1792     ime_error_e retVal = IME_ERROR_NONE;
1793
1794     if (!context || !layout) {
1795         LOGW("IME_ERROR_INVALID_PARAMETER");
1796         return IME_ERROR_INVALID_PARAMETER;
1797     }
1798
1799     retVal = _check_privilege();
1800     if (retVal != IME_ERROR_NONE) return retVal;
1801
1802     if (!g_running) {
1803         LOGW("IME_ERROR_NOT_RUNNING");
1804         return IME_ERROR_NOT_RUNNING;
1805     }
1806
1807     //LCOV_EXCL_START
1808     *layout = context->layout;
1809
1810     return IME_ERROR_NONE;
1811     //LCOV_EXCL_STOP
1812 }
1813
1814 EXPORT_API int ime_context_get_layout_variation(ime_context_h context, ime_layout_variation_e *layout_variation)
1815 {
1816     ime_error_e retVal = IME_ERROR_NONE;
1817
1818     if (!context || !layout_variation) {
1819         LOGW("IME_ERROR_INVALID_PARAMETER");
1820         return IME_ERROR_INVALID_PARAMETER;
1821     }
1822
1823     retVal = _check_privilege();
1824     if (retVal != IME_ERROR_NONE) return retVal;
1825
1826     if (!g_running) {
1827         LOGW("IME_ERROR_NOT_RUNNING");
1828         return IME_ERROR_NOT_RUNNING;
1829     }
1830
1831     //LCOV_EXCL_START
1832     *layout_variation = static_cast<ime_layout_variation_e>(context->layout_variation);
1833
1834     return IME_ERROR_NONE;
1835     //LCOV_EXCL_STOP
1836 }
1837
1838 EXPORT_API int ime_context_get_cursor_position(ime_context_h context, int *cursor_pos)
1839 {
1840     ime_error_e retVal = IME_ERROR_NONE;
1841
1842     if (!context || !cursor_pos) {
1843         LOGW("IME_ERROR_INVALID_PARAMETER");
1844         return IME_ERROR_INVALID_PARAMETER;
1845     }
1846
1847     retVal = _check_privilege();
1848     if (retVal != IME_ERROR_NONE) return retVal;
1849
1850     if (!g_running) {
1851         LOGW("IME_ERROR_NOT_RUNNING");
1852         return IME_ERROR_NOT_RUNNING;
1853     }
1854
1855     //LCOV_EXCL_START
1856     *cursor_pos = context->cursor_pos;
1857
1858     return IME_ERROR_NONE;
1859     //LCOV_EXCL_STOP
1860 }
1861
1862 EXPORT_API int ime_context_get_autocapital_type(ime_context_h context, Ecore_IMF_Autocapital_Type *autocapital_type)
1863 {
1864     ime_error_e retVal = IME_ERROR_NONE;
1865
1866     if (!context || !autocapital_type) {
1867         LOGW("IME_ERROR_INVALID_PARAMETER");
1868         return IME_ERROR_INVALID_PARAMETER;
1869     }
1870
1871     retVal = _check_privilege();
1872     if (retVal != IME_ERROR_NONE) return retVal;
1873
1874     if (!g_running) {
1875         LOGW("IME_ERROR_NOT_RUNNING");
1876         return IME_ERROR_NOT_RUNNING;
1877     }
1878
1879     //LCOV_EXCL_START
1880     *autocapital_type = context->autocapital_type;
1881
1882     return IME_ERROR_NONE;
1883     //LCOV_EXCL_STOP
1884 }
1885
1886 EXPORT_API int ime_context_get_return_key_type(ime_context_h context, Ecore_IMF_Input_Panel_Return_Key_Type *return_key_type)
1887 {
1888     ime_error_e retVal = IME_ERROR_NONE;
1889
1890     if (!context || !return_key_type) {
1891         LOGW("IME_ERROR_INVALID_PARAMETER");
1892         return IME_ERROR_INVALID_PARAMETER;
1893     }
1894
1895     retVal = _check_privilege();
1896     if (retVal != IME_ERROR_NONE) return retVal;
1897
1898     if (!g_running) {
1899         LOGW("IME_ERROR_NOT_RUNNING");
1900         return IME_ERROR_NOT_RUNNING;
1901     }
1902
1903     //LCOV_EXCL_START
1904     *return_key_type = context->return_key_type;
1905
1906     return IME_ERROR_NONE;
1907     //LCOV_EXCL_STOP
1908 }
1909
1910 EXPORT_API int ime_context_get_return_key_state(ime_context_h context, bool *return_key_state)
1911 {
1912     ime_error_e retVal = IME_ERROR_NONE;
1913
1914     if (!context || !return_key_state) {
1915         LOGW("IME_ERROR_INVALID_PARAMETER");
1916         return IME_ERROR_INVALID_PARAMETER;
1917     }
1918
1919     retVal = _check_privilege();
1920     if (retVal != IME_ERROR_NONE) return retVal;
1921
1922     if (!g_running) {
1923         LOGW("IME_ERROR_NOT_RUNNING");
1924         return IME_ERROR_NOT_RUNNING;
1925     }
1926
1927     //LCOV_EXCL_START
1928     *return_key_state = static_cast<bool>(context->return_key_disabled);
1929
1930     return IME_ERROR_NONE;
1931     //LCOV_EXCL_STOP
1932 }
1933
1934 EXPORT_API int ime_context_get_prediction_mode(ime_context_h context, bool *prediction_mode)
1935 {
1936     ime_error_e retVal = IME_ERROR_NONE;
1937
1938     if (!context || !prediction_mode) {
1939         LOGW("IME_ERROR_INVALID_PARAMETER");
1940         return IME_ERROR_INVALID_PARAMETER;
1941     }
1942
1943     retVal = _check_privilege();
1944     if (retVal != IME_ERROR_NONE) return retVal;
1945
1946     if (!g_running) {
1947         LOGW("IME_ERROR_NOT_RUNNING");
1948         return IME_ERROR_NOT_RUNNING;
1949     }
1950
1951     //LCOV_EXCL_START
1952     *prediction_mode = static_cast<bool>(context->prediction_allow);
1953
1954     return IME_ERROR_NONE;
1955     //LCOV_EXCL_STOP
1956 }
1957
1958 EXPORT_API int ime_context_get_password_mode(ime_context_h context, bool *password_mode)
1959 {
1960     ime_error_e retVal = IME_ERROR_NONE;
1961
1962     if (!context || !password_mode) {
1963         LOGW("IME_ERROR_INVALID_PARAMETER");
1964         return IME_ERROR_INVALID_PARAMETER;
1965     }
1966
1967     retVal = _check_privilege();
1968     if (retVal != IME_ERROR_NONE) return retVal;
1969
1970     if (!g_running) {
1971         LOGW("IME_ERROR_NOT_RUNNING");
1972         return IME_ERROR_NOT_RUNNING;
1973     }
1974
1975     //LCOV_EXCL_START
1976     *password_mode = static_cast<bool>(context->password_mode);
1977
1978     return IME_ERROR_NONE;
1979     //LCOV_EXCL_STOP
1980 }
1981
1982 EXPORT_API int ime_context_get_input_hint(ime_context_h context, Ecore_IMF_Input_Hints *input_hint)
1983 {
1984     ime_error_e retVal = IME_ERROR_NONE;
1985
1986     if (!context || !input_hint) {
1987         LOGW("IME_ERROR_INVALID_PARAMETER");
1988         return IME_ERROR_INVALID_PARAMETER;
1989     }
1990
1991     retVal = _check_privilege();
1992     if (retVal != IME_ERROR_NONE) return retVal;
1993
1994     if (!g_running) {
1995         LOGW("IME_ERROR_NOT_RUNNING");
1996         return IME_ERROR_NOT_RUNNING;
1997     }
1998
1999     //LCOV_EXCL_START
2000     *input_hint = context->input_hint;
2001
2002     return IME_ERROR_NONE;
2003     //LCOV_EXCL_STOP
2004 }
2005
2006 EXPORT_API int ime_context_get_bidi_direction(ime_context_h context, Ecore_IMF_BiDi_Direction *bidi)
2007 {
2008     ime_error_e retVal = IME_ERROR_NONE;
2009
2010     if (!context || !bidi) {
2011         LOGW("IME_ERROR_INVALID_PARAMETER");
2012         return IME_ERROR_INVALID_PARAMETER;
2013     }
2014
2015     retVal = _check_privilege();
2016     if (retVal != IME_ERROR_NONE) return retVal;
2017
2018     if (!g_running) {
2019         LOGW("IME_ERROR_NOT_RUNNING");
2020         return IME_ERROR_NOT_RUNNING;
2021     }
2022
2023     //LCOV_EXCL_START
2024     *bidi = context->bidi_direction;
2025
2026     return IME_ERROR_NONE;
2027     //LCOV_EXCL_STOP
2028 }
2029
2030 EXPORT_API int ime_context_get_language(ime_context_h context, Ecore_IMF_Input_Panel_Lang *language)
2031 {
2032     ime_error_e retVal = IME_ERROR_NONE;
2033
2034     if (!context || !language) {
2035         LOGW("IME_ERROR_INVALID_PARAMETER");
2036         return IME_ERROR_INVALID_PARAMETER;
2037     }
2038
2039     retVal = _check_privilege();
2040     if (retVal != IME_ERROR_NONE) return retVal;
2041
2042     if (!g_running) {
2043         LOGW("IME_ERROR_NOT_RUNNING");
2044         return IME_ERROR_NOT_RUNNING;
2045     }
2046
2047     //LCOV_EXCL_START
2048     *language = context->language;
2049
2050     return IME_ERROR_NONE;
2051     //LCOV_EXCL_STOP
2052 }
2053
2054 //LCOV_EXCL_START
2055 EXPORT_API int ime_context_get_caps_mode(ime_context_h context, bool *caps_mode)
2056 {
2057     ime_error_e retVal = IME_ERROR_NONE;
2058
2059     if (!context || !caps_mode) {
2060         LOGW("IME_ERROR_INVALID_PARAMETER");
2061         return IME_ERROR_INVALID_PARAMETER;
2062     }
2063
2064     retVal = _check_privilege();
2065     if (retVal != IME_ERROR_NONE) return retVal;
2066
2067     if (!g_running) {
2068         LOGW("IME_ERROR_NOT_RUNNING");
2069         return IME_ERROR_NOT_RUNNING;
2070     }
2071
2072     *caps_mode = static_cast<bool>(context->caps_mode);
2073
2074     return IME_ERROR_NONE;
2075 }
2076 //LCOV_EXCL_STOP
2077
2078 EXPORT_API int ime_device_info_get_name(ime_device_info_h dev_info, char **dev_name)
2079 {
2080     ime_error_e retVal = IME_ERROR_NONE;
2081
2082     if (!dev_info || !dev_name) {
2083         LOGW("IME_ERROR_INVALID_PARAMETER");
2084         return IME_ERROR_INVALID_PARAMETER;
2085     }
2086
2087     retVal = _check_privilege();
2088     if (retVal != IME_ERROR_NONE) return retVal;
2089
2090     if (!g_running) {
2091         LOGW("IME_ERROR_NOT_RUNNING");
2092         return IME_ERROR_NOT_RUNNING;
2093     }
2094
2095     //LCOV_EXCL_START
2096     if (!dev_info->dev_name)
2097         *dev_name = strdup("");
2098     else
2099         *dev_name = strdup(dev_info->dev_name);
2100
2101     return IME_ERROR_NONE;
2102     //LCOV_EXCL_STOP
2103 }
2104
2105 EXPORT_API int ime_device_info_get_class(ime_device_info_h dev_info, Ecore_IMF_Device_Class *dev_class)
2106 {
2107     ime_error_e retVal = IME_ERROR_NONE;
2108
2109     if (!dev_info || !dev_class) {
2110         LOGW("IME_ERROR_INVALID_PARAMETER");
2111         return IME_ERROR_INVALID_PARAMETER;
2112     }
2113
2114     retVal = _check_privilege();
2115     if (retVal != IME_ERROR_NONE) return retVal;
2116
2117     if (!g_running) {
2118         LOGW("IME_ERROR_NOT_RUNNING");
2119         return IME_ERROR_NOT_RUNNING;
2120     }
2121
2122     //LCOV_EXCL_START
2123     *dev_class = dev_info->dev_class;
2124
2125     return IME_ERROR_NONE;
2126     //LCOV_EXCL_STOP
2127 }
2128
2129 EXPORT_API int ime_device_info_get_subclass(ime_device_info_h dev_info, Ecore_IMF_Device_Subclass *dev_subclass)
2130 {
2131     ime_error_e retVal = IME_ERROR_NONE;
2132
2133     if (!dev_info || !dev_subclass) {
2134         LOGW("IME_ERROR_INVALID_PARAMETER");
2135         return IME_ERROR_INVALID_PARAMETER;
2136     }
2137
2138     retVal = _check_privilege();
2139     if (retVal != IME_ERROR_NONE) return retVal;
2140
2141     if (!g_running) {
2142         LOGW("IME_ERROR_NOT_RUNNING");
2143         return IME_ERROR_NOT_RUNNING;
2144     }
2145
2146     //LCOV_EXCL_START
2147     *dev_subclass = dev_info->dev_subclass;
2148
2149     return IME_ERROR_NONE;
2150     //LCOV_EXCL_STOP
2151 }
2152
2153 //LCOV_EXCL_START
2154 EXPORT_API int ime_event_set_process_input_device_event_cb(ime_process_input_device_event_cb callback_func, void *user_data)
2155 {
2156     ime_error_e retVal = IME_ERROR_NONE;
2157
2158     if (!callback_func) {
2159         LOGW("IME_ERROR_INVALID_PARAMETER");
2160         return IME_ERROR_INVALID_PARAMETER;
2161     }
2162
2163     retVal = _check_privilege();
2164     if (retVal != IME_ERROR_NONE) return retVal;
2165
2166     g_event_callback.process_input_device_event = callback_func;
2167     g_event_callback.process_input_device_event_user_data = user_data;
2168
2169     return IME_ERROR_NONE;
2170 }
2171
2172 EXPORT_API int ime_event_unset_process_input_device_event_cb(void)
2173 {
2174     ime_error_e retVal = IME_ERROR_NONE;
2175
2176     retVal = _check_privilege();
2177     if (retVal != IME_ERROR_NONE) return retVal;
2178
2179     g_event_callback.process_input_device_event = NULL;
2180     g_event_callback.process_input_device_event_user_data = NULL;
2181
2182     return IME_ERROR_NONE;
2183 }
2184
2185 /* Functions for Rotary input device event */
2186 EXPORT_API int ime_input_device_rotary_get_direction(ime_input_device_event_h event_handle, ime_input_device_rotary_direction_e *direction)
2187 {
2188     ime_error_e retVal = IME_ERROR_NONE;
2189
2190     if (!event_handle || !direction) {
2191         LOGW("IME_ERROR_INVALID_PARAMETER");
2192         return IME_ERROR_INVALID_PARAMETER;
2193     }
2194
2195     ime_device_event_s *device_event = static_cast<ime_device_event_s*>(event_handle);
2196     if (device_event->device_type != IME_INPUT_DEVICE_TYPE_ROTARY) {
2197         LOGW("IME_ERROR_INVALID_PARAMETER");
2198         return IME_ERROR_INVALID_PARAMETER;
2199     }
2200
2201     retVal = _check_privilege();
2202     if (retVal != IME_ERROR_NONE) return retVal;
2203
2204     if (!g_running) {
2205         LOGW("IME_ERROR_OPERATION_FAILED");
2206         return IME_ERROR_OPERATION_FAILED;
2207     }
2208
2209     //LCOV_EXCL_START
2210     Ecore_Event_Detent_Rotate *rotary_device_event =
2211         static_cast<Ecore_Event_Detent_Rotate*>(device_event->event_data);
2212     if (rotary_device_event) {
2213         if (rotary_device_event->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) {
2214             *direction = IME_INPUT_DEVICE_ROTARY_DIRECTION_CLOCKWISE;
2215         } else if (rotary_device_event->direction == ECORE_DETENT_DIRECTION_COUNTER_CLOCKWISE) {
2216             *direction = IME_INPUT_DEVICE_ROTARY_DIRECTION_COUNTER_CLOCKWISE;
2217         }
2218     }
2219
2220     return IME_ERROR_NONE;
2221     //LCOV_EXCL_STOP
2222 }
2223 //LCOV_EXCL_STOP
2224
2225 EXPORT_API int ime_event_set_prediction_hint_set_cb(ime_prediction_hint_set_cb callback_func, void *user_data)
2226 {
2227     ime_error_e retVal = IME_ERROR_NONE;
2228
2229     if (!callback_func) {
2230         LOGW("IME_ERROR_INVALID_PARAMETER");
2231         return IME_ERROR_INVALID_PARAMETER;
2232     }
2233
2234     retVal = _check_privilege();
2235     if (retVal != IME_ERROR_NONE) return retVal;
2236
2237     g_event_callback.prediction_hint_set = callback_func;
2238     g_event_callback.prediction_hint_set_user_data = user_data;
2239
2240     return IME_ERROR_NONE;
2241 }
2242
2243 EXPORT_API int ime_event_set_mime_type_set_request_cb(ime_mime_type_set_request_cb callback_func, void *user_data)
2244 {
2245     ime_error_e retVal = IME_ERROR_NONE;
2246
2247     if (!callback_func) {
2248         LOGW("IME_ERROR_INVALID_PARAMETER");
2249         return IME_ERROR_INVALID_PARAMETER;
2250     }
2251
2252     retVal = _check_privilege();
2253     if (retVal != IME_ERROR_NONE) return retVal;
2254
2255     g_event_callback.mime_type_set = callback_func;
2256     g_event_callback.mime_type_set_user_data = user_data;
2257
2258     return IME_ERROR_NONE;
2259 }
2260
2261 EXPORT_API int ime_set_floating_mode(bool floating_mode)
2262 {
2263     ime_error_e retVal = IME_ERROR_NONE;
2264
2265     retVal = _check_privilege();
2266     if (retVal != IME_ERROR_NONE) return retVal;
2267
2268     if (!g_running) {
2269         LOGW("IME_ERROR_NOT_RUNNING");
2270         return IME_ERROR_NOT_RUNNING;
2271     }
2272
2273     //LCOV_EXCL_START
2274     g_core.set_floating_mode(floating_mode);
2275
2276     return IME_ERROR_NONE;
2277     //LCOV_EXCL_STOP
2278 }
2279
2280 EXPORT_API int ime_set_floating_drag_start(void)
2281 {
2282     ime_error_e retVal = IME_ERROR_NONE;
2283
2284     retVal = _check_privilege();
2285     if (retVal != IME_ERROR_NONE) return retVal;
2286
2287     if (!g_running) {
2288         LOGW("IME_ERROR_NOT_RUNNING");
2289         return IME_ERROR_NOT_RUNNING;
2290     }
2291
2292     //LCOV_EXCL_START
2293     g_core.set_floating_drag_enabled(true);
2294
2295     return IME_ERROR_NONE;
2296     //LCOV_EXCL_STOP
2297 }
2298
2299 EXPORT_API int ime_set_floating_drag_end(void)
2300 {
2301     ime_error_e retVal = IME_ERROR_NONE;
2302
2303     retVal = _check_privilege();
2304     if (retVal != IME_ERROR_NONE) return retVal;
2305
2306     if (!g_running) {
2307         LOGW("IME_ERROR_NOT_RUNNING");
2308         return IME_ERROR_NOT_RUNNING;
2309     }
2310
2311     //LCOV_EXCL_START
2312     g_core.set_floating_drag_enabled(false);
2313
2314     return IME_ERROR_NONE;
2315     //LCOV_EXCL_STOP
2316 }
2317
2318 //LCOV_EXCL_START
2319 EXPORT_API int ime_set_window_creation_defer_flag(bool flag)
2320 {
2321     ime_error_e retVal = IME_ERROR_NONE;
2322
2323     retVal = _check_privilege();
2324     if (retVal != IME_ERROR_NONE) return retVal;
2325
2326     g_core.set_window_creation_defer_flag(flag);
2327
2328     return IME_ERROR_NONE;
2329 }
2330 //LCOV_EXCL_STOP
2331
2332 EXPORT_API int ime_event_set_prediction_hint_data_set_cb(ime_prediction_hint_data_set_cb callback_func, void *user_data)
2333 {
2334     ime_error_e retVal = IME_ERROR_NONE;
2335
2336     if (!callback_func) {
2337         LOGW("IME_ERROR_INVALID_PARAMETER");
2338         return IME_ERROR_INVALID_PARAMETER;
2339     }
2340
2341     retVal = _check_privilege();
2342     if (retVal != IME_ERROR_NONE) return retVal;
2343
2344     g_event_callback.prediction_hint_data_set = callback_func;
2345     g_event_callback.prediction_hint_data_set_user_data = user_data;
2346
2347     return IME_ERROR_NONE;
2348 }
2349
2350 //LCOV_EXCL_START
2351 EXPORT_API int ime_event_set_optimization_hint_set_cb(ime_optimization_hint_set_cb callback_func, void *user_data)
2352 {
2353     LOGD("");
2354     ime_error_e retVal = IME_ERROR_NONE;
2355
2356     if (!callback_func) {
2357         LOGW("IME_ERROR_INVALID_PARAMETER");
2358         return IME_ERROR_INVALID_PARAMETER;
2359     }
2360
2361     LOGD("");
2362     retVal = _check_privilege();
2363     if (retVal != IME_ERROR_NONE) return retVal;
2364
2365     LOGD("");
2366     g_event_callback.optimization_hint_set = callback_func;
2367     g_event_callback.optimization_hint_set_user_data = user_data;
2368
2369     return IME_ERROR_NONE;
2370 }
2371
2372 EXPORT_API int ime_event_set_process_key_event_with_imengine_cb(ime_process_key_event_with_imengine_cb callback_func, void *user_data)
2373 {
2374     LOGD("");
2375     ime_error_e retVal = IME_ERROR_NONE;
2376
2377     if (!callback_func) {
2378         LOGW("IME_ERROR_INVALID_PARAMETER");
2379         return IME_ERROR_INVALID_PARAMETER;
2380     }
2381
2382     retVal = _check_privilege();
2383     if (retVal != IME_ERROR_NONE) return retVal;
2384
2385     g_event_callback.process_key_event_with_imengine = callback_func;
2386     g_event_callback.process_key_event_with_imengine_user_data = user_data;
2387
2388     return IME_ERROR_NONE;
2389 }
2390
2391 EXPORT_API int ime_event_set_autocapital_type_set_cb(ime_autocapital_type_set_cb callback_func, void *user_data)
2392 {
2393     LOGD("");
2394     ime_error_e retVal = IME_ERROR_NONE;
2395
2396     if (!callback_func) {
2397         LOGW("IME_ERROR_INVALID_PARAMETER");
2398         return IME_ERROR_INVALID_PARAMETER;
2399     }
2400
2401     retVal = _check_privilege();
2402     if (retVal != IME_ERROR_NONE) return retVal;
2403
2404     g_event_callback.autocapital_type_set = callback_func;
2405     g_event_callback.autocapital_type_set_user_data = user_data;
2406
2407     return IME_ERROR_NONE;
2408 }
2409
2410 EXPORT_API int ime_event_set_prediction_allow_set_cb(ime_prediction_allow_set_cb callback_func, void *user_data)
2411 {
2412     LOGD("");
2413     ime_error_e retVal = IME_ERROR_NONE;
2414
2415     if (!callback_func) {
2416         LOGW("IME_ERROR_INVALID_PARAMETER");
2417         return IME_ERROR_INVALID_PARAMETER;
2418     }
2419
2420     retVal = _check_privilege();
2421     if (retVal != IME_ERROR_NONE) return retVal;
2422
2423     g_event_callback.prediction_allow_set = callback_func;
2424     g_event_callback.prediction_allow_set_user_data = user_data;
2425
2426     return IME_ERROR_NONE;
2427 }
2428
2429 EXPORT_API int ime_event_set_trigger_property_set_cb(ime_trigger_property_set_cb callback_func, void *user_data)
2430 {
2431     LOGD("");
2432     ime_error_e retVal = IME_ERROR_NONE;
2433
2434     if (!callback_func) {
2435         LOGW("IME_ERROR_INVALID_PARAMETER");
2436         return IME_ERROR_INVALID_PARAMETER;
2437     }
2438
2439     retVal = _check_privilege();
2440     if (retVal != IME_ERROR_NONE) return retVal;
2441
2442     g_event_callback.trigger_property_set = callback_func;
2443     g_event_callback.trigger_property_set_user_data = user_data;
2444
2445     return IME_ERROR_NONE;
2446 }
2447
2448 EXPORT_API int ime_event_set_candidate_more_window_show_cb(ime_candidate_more_window_show_cb callback_func, void *user_data)
2449 {
2450     LOGD("");
2451     ime_error_e retVal = IME_ERROR_NONE;
2452
2453     if (!callback_func) {
2454         LOGW("IME_ERROR_INVALID_PARAMETER");
2455         return IME_ERROR_INVALID_PARAMETER;
2456     }
2457
2458     retVal = _check_privilege();
2459     if (retVal != IME_ERROR_NONE) return retVal;
2460
2461     g_event_callback.candidate_more_window_show = callback_func;
2462     g_event_callback.candidate_more_window_show_user_data = user_data;
2463
2464     return IME_ERROR_NONE;
2465 }
2466
2467 EXPORT_API int ime_event_set_candidate_more_window_hide_cb(ime_candidate_more_window_hide_cb callback_func, void *user_data)
2468 {
2469     LOGD("");
2470     ime_error_e retVal = IME_ERROR_NONE;
2471
2472     if (!callback_func) {
2473         LOGW("IME_ERROR_INVALID_PARAMETER");
2474         return IME_ERROR_INVALID_PARAMETER;
2475     }
2476
2477     retVal = _check_privilege();
2478     if (retVal != IME_ERROR_NONE) return retVal;
2479
2480     g_event_callback.candidate_more_window_hide = callback_func;
2481     g_event_callback.candidate_more_window_hide_user_data = user_data;
2482
2483     return IME_ERROR_NONE;
2484 }
2485
2486 EXPORT_API int ime_event_set_aux_select_cb(ime_aux_select_cb callback_func, void *user_data)
2487 {
2488     LOGD("");
2489     ime_error_e retVal = IME_ERROR_NONE;
2490
2491     if (!callback_func) {
2492         LOGW("IME_ERROR_INVALID_PARAMETER");
2493         return IME_ERROR_INVALID_PARAMETER;
2494     }
2495
2496     retVal = _check_privilege();
2497     if (retVal != IME_ERROR_NONE) return retVal;
2498
2499     g_event_callback.aux_select = callback_func;
2500     g_event_callback.aux_select_user_data = user_data;
2501
2502     return IME_ERROR_NONE;
2503 }
2504
2505 EXPORT_API int ime_event_set_candidate_select_cb(ime_candidate_select_cb callback_func, void *user_data)
2506 {
2507     LOGD("");
2508     ime_error_e retVal = IME_ERROR_NONE;
2509
2510     if (!callback_func) {
2511         LOGW("IME_ERROR_INVALID_PARAMETER");
2512         return IME_ERROR_INVALID_PARAMETER;
2513     }
2514
2515     retVal = _check_privilege();
2516     if (retVal != IME_ERROR_NONE) return retVal;
2517
2518     g_event_callback.candidate_select = callback_func;
2519     g_event_callback.candidate_select_user_data = user_data;
2520
2521     return IME_ERROR_NONE;
2522 }
2523
2524 EXPORT_API int ime_event_set_candidate_table_page_up_cb(ime_candidate_table_page_up_cb callback_func, void *user_data)
2525 {
2526     LOGD("");
2527     ime_error_e retVal = IME_ERROR_NONE;
2528
2529     if (!callback_func) {
2530         LOGW("IME_ERROR_INVALID_PARAMETER");
2531         return IME_ERROR_INVALID_PARAMETER;
2532     }
2533
2534     retVal = _check_privilege();
2535     if (retVal != IME_ERROR_NONE) return retVal;
2536
2537     g_event_callback.candidate_table_page_up = callback_func;
2538     g_event_callback.candidate_table_page_up_user_data = user_data;
2539
2540     return IME_ERROR_NONE;
2541 }
2542
2543 EXPORT_API int ime_event_set_candidate_table_page_down_cb(ime_candidate_table_page_down_cb callback_func, void *user_data)
2544 {
2545     LOGD("");
2546     ime_error_e retVal = IME_ERROR_NONE;
2547
2548     if (!callback_func) {
2549         LOGW("IME_ERROR_INVALID_PARAMETER");
2550         return IME_ERROR_INVALID_PARAMETER;
2551     }
2552
2553     retVal = _check_privilege();
2554     if (retVal != IME_ERROR_NONE) return retVal;
2555
2556     g_event_callback.candidate_table_page_down = callback_func;
2557     g_event_callback.candidate_table_page_down_user_data = user_data;
2558
2559     return IME_ERROR_NONE;
2560 }
2561
2562 EXPORT_API int ime_event_set_candidate_table_page_size_chaned_cb(ime_candidate_table_page_size_chaned_cb callback_func, void *user_data)
2563 {
2564     LOGD("");
2565     ime_error_e retVal = IME_ERROR_NONE;
2566
2567     if (!callback_func) {
2568         LOGW("IME_ERROR_INVALID_PARAMETER");
2569         return IME_ERROR_INVALID_PARAMETER;
2570     }
2571
2572     retVal = _check_privilege();
2573     if (retVal != IME_ERROR_NONE) return retVal;
2574
2575     g_event_callback.candidate_table_page_size_chaned = callback_func;
2576     g_event_callback.candidate_table_page_size_chaned_user_data = user_data;
2577
2578     return IME_ERROR_NONE;
2579 }
2580
2581 EXPORT_API int ime_event_set_candidate_item_layout_set_cb(ime_candidate_item_layout_set_cb callback_func, void *user_data)
2582 {
2583     LOGD("");
2584     ime_error_e retVal = IME_ERROR_NONE;
2585
2586     if (!callback_func) {
2587         LOGW("IME_ERROR_INVALID_PARAMETER");
2588         return IME_ERROR_INVALID_PARAMETER;
2589     }
2590
2591     retVal = _check_privilege();
2592     if (retVal != IME_ERROR_NONE) return retVal;
2593
2594     g_event_callback.candidate_item_layout_set = callback_func;
2595     g_event_callback.candidate_item_layout_set_user_data = user_data;
2596
2597     return IME_ERROR_NONE;
2598 }
2599
2600 EXPORT_API int ime_event_set_displayed_candidate_number_chaned_cb(ime_displayed_candidate_number_chaned_cb callback_func, void *user_data)
2601 {
2602     LOGD("");
2603     ime_error_e retVal = IME_ERROR_NONE;
2604
2605     if (!callback_func) {
2606         LOGW("IME_ERROR_INVALID_PARAMETER");
2607         return IME_ERROR_INVALID_PARAMETER;
2608     }
2609
2610     retVal = _check_privilege();
2611     if (retVal != IME_ERROR_NONE) return retVal;
2612
2613     g_event_callback.displayed_candidate_number_chaned = callback_func;
2614     g_event_callback.displayed_candidate_number_chaned_user_data = user_data;
2615
2616     return IME_ERROR_NONE;
2617 }
2618
2619 EXPORT_API int ime_event_set_candidate_item_long_pressed_cb(ime_candidate_item_long_pressed_cb callback_func, void *user_data)
2620 {
2621     LOGD("");
2622     ime_error_e retVal = IME_ERROR_NONE;
2623
2624     if (!callback_func) {
2625         LOGW("IME_ERROR_INVALID_PARAMETER");
2626         return IME_ERROR_INVALID_PARAMETER;
2627     }
2628
2629     retVal = _check_privilege();
2630     if (retVal != IME_ERROR_NONE) return retVal;
2631
2632     g_event_callback.candidate_item_long_pressed = callback_func;
2633     g_event_callback.candidate_item_long_pressed_user_data = user_data;
2634
2635     return IME_ERROR_NONE;
2636 }
2637
2638 EXPORT_API int ime_show_aux_string(void)
2639 {
2640     ime_error_e retVal = IME_ERROR_NONE;
2641
2642     retVal = _check_privilege();
2643     if (retVal != IME_ERROR_NONE) return retVal;
2644
2645     if (!g_running) {
2646         LOGW("IME_ERROR_NOT_RUNNING");
2647         return IME_ERROR_NOT_RUNNING;
2648     }
2649
2650     g_core.show_aux_string();
2651
2652     return IME_ERROR_NONE;
2653 }
2654
2655 EXPORT_API int ime_hide_aux_string(void)
2656 {
2657     ime_error_e retVal = IME_ERROR_NONE;
2658
2659     retVal = _check_privilege();
2660     if (retVal != IME_ERROR_NONE) return retVal;
2661
2662     if (!g_running) {
2663         LOGW("IME_ERROR_NOT_RUNNING");
2664         return IME_ERROR_NOT_RUNNING;
2665     }
2666
2667     g_core.hide_aux_string();
2668
2669     return IME_ERROR_NONE;
2670 }
2671
2672 EXPORT_API int ime_show_lookup_table(void)
2673 {
2674     ime_error_e retVal = IME_ERROR_NONE;
2675
2676     retVal = _check_privilege();
2677     if (retVal != IME_ERROR_NONE) return retVal;
2678
2679     if (!g_running) {
2680         LOGW("IME_ERROR_NOT_RUNNING");
2681         return IME_ERROR_NOT_RUNNING;
2682     }
2683
2684     g_core.show_candidate_string();
2685
2686     return IME_ERROR_NONE;
2687 }
2688
2689 EXPORT_API int ime_hide_lookup_table(void)
2690 {
2691     ime_error_e retVal = IME_ERROR_NONE;
2692
2693     retVal = _check_privilege();
2694     if (retVal != IME_ERROR_NONE) return retVal;
2695
2696     if (!g_running) {
2697         LOGW("IME_ERROR_NOT_RUNNING");
2698         return IME_ERROR_NOT_RUNNING;
2699     }
2700
2701     g_core.hide_candidate_string();
2702
2703     return IME_ERROR_NONE;
2704 }
2705
2706 EXPORT_API int ime_update_preedit_caret(int caret)
2707 {
2708     ime_error_e retVal = IME_ERROR_NONE;
2709
2710     if (caret < 0) {
2711         LOGW("IME_ERROR_INVALID_PARAMETER");
2712         return IME_ERROR_INVALID_PARAMETER;
2713     }
2714
2715     if (!g_running) {
2716         LOGW("IME_ERROR_NOT_RUNNING");
2717         return IME_ERROR_NOT_RUNNING;
2718     }
2719
2720     retVal = _check_privilege();
2721     if (retVal != IME_ERROR_NONE) return retVal;
2722
2723     g_core.update_preedit_caret(caret);
2724
2725     return IME_ERROR_NONE;
2726 }
2727
2728 EXPORT_API int ime_update_preedit_string_with_commit(const char *preedit, const char *commit, scim::AttributeList &attrs, int caret)
2729 {
2730     ime_error_e retVal = IME_ERROR_NONE;
2731
2732     if (!preedit && !commit) {
2733         LOGW("IME_ERROR_INVALID_PARAMETER");
2734         return IME_ERROR_INVALID_PARAMETER;
2735     }
2736
2737     if (!g_running) {
2738         LOGW("IME_ERROR_NOT_RUNNING");
2739         return IME_ERROR_NOT_RUNNING;
2740     }
2741
2742     retVal = _check_privilege();
2743     if (retVal != IME_ERROR_NONE) return retVal;
2744
2745     g_core.update_preedit_string_with_commit(preedit, commit, attrs, caret);
2746
2747     return IME_ERROR_NONE;
2748 }
2749
2750 EXPORT_API int ime_update_aux_string(const char *str)
2751 {
2752     ime_error_e retVal = IME_ERROR_NONE;
2753
2754     if (!str) {
2755         LOGW("IME_ERROR_INVALID_PARAMETER");
2756         return IME_ERROR_INVALID_PARAMETER;
2757     }
2758
2759     if (!g_running) {
2760         LOGW("IME_ERROR_NOT_RUNNING");
2761         return IME_ERROR_NOT_RUNNING;
2762     }
2763
2764     retVal = _check_privilege();
2765     if (retVal != IME_ERROR_NONE) return retVal;
2766
2767     g_core.update_aux_string(str);
2768
2769     return IME_ERROR_NONE;
2770 }
2771
2772 EXPORT_API int ime_recapture_string(int offset, int len, const char *preedit, const char *commit, scim::AttributeList &attrs)
2773 {
2774     ime_error_e retVal = IME_ERROR_NONE;
2775
2776     if (len < 0) {
2777         LOGW("IME_ERROR_INVALID_PARAMETER");
2778         return IME_ERROR_INVALID_PARAMETER;
2779     }
2780
2781     if (!g_running) {
2782         LOGW("IME_ERROR_NOT_RUNNING");
2783         return IME_ERROR_NOT_RUNNING;
2784     }
2785
2786     retVal = _check_privilege();
2787     if (retVal != IME_ERROR_NONE) return retVal;
2788
2789     g_core.recapture_string(offset, len, preedit, commit, attrs);
2790
2791     return IME_ERROR_NONE;
2792 }
2793
2794 EXPORT_API int ime_update_lookup_table(scim::LookupTable &table)
2795 {
2796     ime_error_e retVal = IME_ERROR_NONE;
2797
2798     if (!g_running) {
2799         LOGW("IME_ERROR_NOT_RUNNING");
2800         return IME_ERROR_NOT_RUNNING;
2801     }
2802
2803     retVal = _check_privilege();
2804     if (retVal != IME_ERROR_NONE) return retVal;
2805
2806     g_core.update_lookup_table(table);
2807
2808     return IME_ERROR_NONE;
2809 }
2810
2811 EXPORT_API int ime_register_properties(scim::PropertyList &properties)
2812 {
2813     ime_error_e retVal = IME_ERROR_NONE;
2814
2815     if (!g_running) {
2816         LOGW("IME_ERROR_NOT_RUNNING");
2817         return IME_ERROR_NOT_RUNNING;
2818     }
2819
2820     retVal = _check_privilege();
2821     if (retVal != IME_ERROR_NONE) return retVal;
2822
2823     g_core.register_properties(properties);
2824
2825     return IME_ERROR_NONE;
2826 }
2827
2828 EXPORT_API int ime_update_property(scim::Property &property)
2829 {
2830     ime_error_e retVal = IME_ERROR_NONE;
2831
2832     if (!g_running) {
2833         LOGW("IME_ERROR_NOT_RUNNING");
2834         return IME_ERROR_NOT_RUNNING;
2835     }
2836
2837     retVal = _check_privilege();
2838     if (retVal != IME_ERROR_NONE) return retVal;
2839
2840     g_core.update_property(property);
2841
2842     return IME_ERROR_NONE;
2843 }
2844
2845 EXPORT_API int ime_expand_candidate(void)
2846 {
2847     ime_error_e retVal = IME_ERROR_NONE;
2848
2849     retVal = _check_privilege();
2850     if (retVal != IME_ERROR_NONE) return retVal;
2851
2852     if (!g_running) {
2853         LOGW("IME_ERROR_NOT_RUNNING");
2854         return IME_ERROR_NOT_RUNNING;
2855     }
2856
2857     g_core.expand_candidate();
2858
2859     return IME_ERROR_NONE;
2860 }
2861
2862 EXPORT_API int ime_contract_candidate(void)
2863 {
2864     ime_error_e retVal = IME_ERROR_NONE;
2865
2866     retVal = _check_privilege();
2867     if (retVal != IME_ERROR_NONE) return retVal;
2868
2869     if (!g_running) {
2870         LOGW("IME_ERROR_NOT_RUNNING");
2871         return IME_ERROR_NOT_RUNNING;
2872     }
2873
2874     g_core.contract_candidate();
2875
2876     return IME_ERROR_NONE;
2877 }
2878
2879 EXPORT_API int ime_set_candidate_style(scim::ISF_CANDIDATE_PORTRAIT_LINE_T portrait_line, scim::ISF_CANDIDATE_MODE_T mode)
2880 {
2881     ime_error_e retVal = IME_ERROR_NONE;
2882
2883     if (!g_running) {
2884         LOGW("IME_ERROR_NOT_RUNNING");
2885         return IME_ERROR_NOT_RUNNING;
2886     }
2887
2888     retVal = _check_privilege();
2889     if (retVal != IME_ERROR_NONE) return retVal;
2890
2891     g_core.set_candidate_style(portrait_line, mode);
2892
2893     return IME_ERROR_NONE;
2894 }
2895
2896 EXPORT_API int ime_set_engine_loader_flag(bool flag)
2897 {
2898     ime_error_e retVal = IME_ERROR_NONE;
2899
2900     if (!g_running) {
2901         LOGW("IME_ERROR_NOT_RUNNING");
2902         return IME_ERROR_NOT_RUNNING;
2903     }
2904
2905     retVal = _check_privilege();
2906     if (retVal != IME_ERROR_NONE) return retVal;
2907
2908     g_core.set_engine_loader_flag(flag);
2909
2910     return IME_ERROR_NONE;
2911 }
2912
2913 EXPORT_API int ime_send_key_event_processing_result(scim::KeyEvent &key, uint32_t serial, bool is_success)
2914 {
2915     ime_error_e retVal = IME_ERROR_NONE;
2916
2917     if (!g_running) {
2918         LOGW("IME_ERROR_NOT_RUNNING");
2919         return IME_ERROR_NOT_RUNNING;
2920     }
2921
2922     retVal = _check_privilege();
2923     if (retVal != IME_ERROR_NONE) return retVal;
2924
2925     g_core.send_key_event_processing_result(key, serial, is_success);
2926
2927     return IME_ERROR_NONE;
2928 }
2929 //LCOV_EXCL_STOP
2930
2931 EXPORT_API int ime_update_input_panel_event(ime_event_type_e type, unsigned int value)
2932 {
2933     ime_error_e retVal = IME_ERROR_NONE;
2934
2935     if (type < IME_EVENT_TYPE_LANGUAGE || type > IME_EVENT_TYPE_GEOMETRY) {
2936         LOGW("IME_ERROR_INVALID_PARAMETER");
2937         return IME_ERROR_INVALID_PARAMETER;
2938     }
2939
2940     if (!g_running) {
2941         LOGW("IME_ERROR_NOT_RUNNING");
2942         return IME_ERROR_NOT_RUNNING;
2943     }
2944
2945     //LCOV_EXCL_START
2946     retVal = _check_privilege();
2947     if (retVal != IME_ERROR_NONE) return retVal;
2948
2949     g_core.update_input_context((sclu32)type, value);
2950
2951     return IME_ERROR_NONE;
2952     //LCOV_EXCL_STOP
2953 }
2954
2955 EXPORT_API int ime_set_candidate_visibility_state(bool visible)
2956 {
2957     ime_error_e retVal = IME_ERROR_NONE;
2958
2959     if (!g_running) {
2960         LOGW("IME_ERROR_NOT_RUNNING");
2961         return IME_ERROR_NOT_RUNNING;
2962     }
2963
2964     //LCOV_EXCL_START
2965     retVal = _check_privilege();
2966     if (retVal != IME_ERROR_NONE) return retVal;
2967
2968     if (visible)
2969         g_core.show_candidate_string();
2970     else
2971         g_core.hide_candidate_string();
2972
2973     return IME_ERROR_NONE;
2974     //LCOV_EXCL_STOP
2975 }