inputmethod/src/inputmethod.cpp

   1 /*
   2  * Copyright (c) 2015 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 *ret);
  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 *ret)
 553 {
 554     if (g_event_callback.process_key_event_with_imengine) {
 555         bool processed = g_event_callback.process_key_event_with_imengine(key, g_event_callback.process_key_event_with_imengine_user_data);
 556
 557         if (ret)
 558             *ret = processed ? 1 : 0;
 559     } else {
 560         if (ret) *ret = 0;
 561     }
 562 }
 563
 564 void CCoreEventCallback::on_set_autocapital_type(sclu32 type)
 565 {
 566     if (g_event_callback.autocapital_type_set) {
 567         g_event_callback.autocapital_type_set(type, g_event_callback.autocapital_type_set_user_data);
 568     }
 569 }
 570
 571 void CCoreEventCallback::on_set_prediction_allow(sclu32 prediction_allow)
 572 {
 573     if (g_event_callback.prediction_allow_set) {
 574         g_event_callback.prediction_allow_set(prediction_allow, g_event_callback.prediction_allow_set_user_data);
 575     }
 576 }
 577
 578 void CCoreEventCallback::on_trigger_property(const sclchar *property)
 579 {
 580     if (g_event_callback.trigger_property_set) {
 581         g_event_callback.trigger_property_set(property, g_event_callback.trigger_property_set_user_data);
 582     }
 583 }
 584
 585 void CCoreEventCallback::on_candidate_more_window_show(sclint ic, const sclchar *uuid)
 586 {
 587     if (g_event_callback.candidate_more_window_show) {
 588         g_event_callback.candidate_more_window_show(g_event_callback.candidate_more_window_show_user_data);
 589     }
 590 }
 591
 592 void CCoreEventCallback::on_candidate_more_window_hide(sclint ic, const sclchar *uuid)
 593 {
 594     if (g_event_callback.candidate_more_window_hide) {
 595         g_event_callback.candidate_more_window_hide(g_event_callback.candidate_more_window_hide_user_data);
 596     }
 597 }
 598
 599 void CCoreEventCallback::on_select_aux(sclint ic, const sclchar *uuid, sclint index)
 600 {
 601     if (g_event_callback.aux_select) {
 602         g_event_callback.aux_select((uint32_t)index, g_event_callback.aux_select_user_data);
 603     }
 604 }
 605
 606 void CCoreEventCallback::on_select_candidate(sclint ic, const sclchar *uuid, sclint index)
 607 {
 608     if (g_event_callback.candidate_select) {
 609         g_event_callback.candidate_select((uint32_t)index, g_event_callback.candidate_select_user_data);
 610     }
 611 }
 612
 613 void CCoreEventCallback::on_candidate_table_page_up(sclint ic, const sclchar *uuid)
 614 {
 615     if (g_event_callback.candidate_table_page_up) {
 616         g_event_callback.candidate_table_page_up(g_event_callback.candidate_table_page_up_user_data);
 617     }
 618 }
 619
 620 void CCoreEventCallback::on_candidate_table_page_down(sclint ic, const sclchar *uuid)
 621 {
 622     if (g_event_callback.candidate_table_page_down) {
 623         g_event_callback.candidate_table_page_down(g_event_callback.candidate_table_page_down_user_data);
 624     }
 625 }
 626
 627 void CCoreEventCallback::on_update_candidate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size)
 628 {
 629     if (g_event_callback.candidate_table_page_size_chaned) {
 630         g_event_callback.candidate_table_page_size_chaned((uint32_t)page_size, g_event_callback.candidate_table_page_size_chaned_user_data);
 631     }
 632 }
 633
 634 void CCoreEventCallback::on_update_candidate_item_layout(const std::vector<sclu32> item)
 635 {
 636     if (g_event_callback.candidate_item_layout_set) {
 637         g_event_callback.candidate_item_layout_set(item, g_event_callback.candidate_item_layout_set_user_data);
 638     }
 639 }
 640
 641 void CCoreEventCallback::on_update_displayed_candidate_number(sclu32 size)
 642 {
 643     if (g_event_callback.displayed_candidate_number_chaned) {
 644         g_event_callback.displayed_candidate_number_chaned(size, g_event_callback.displayed_candidate_number_chaned_user_data);
 645     }
 646 }
 647
 648 void CCoreEventCallback::on_longpress_candidate(sclu32 index)
 649 {
 650     if (g_event_callback.candidate_item_long_pressed) {
 651         g_event_callback.candidate_item_long_pressed(index, g_event_callback.candidate_item_long_pressed_user_data);
 652     }
 653 }
 654
 655 void ime_privilege_cache_init()
 656 {
 657     g_permission_allowed = false;
 658     g_checked_privilege = false;
 659 }
 660 //LCOV_EXCL_STOP
 661
 662 ime_error_e _check_privilege()
 663 {
 664     char uid[16];
 665     ime_error_e ret = IME_ERROR_NONE;
 666
 667     if (g_checked_privilege) {
 668         return g_permission_allowed ? IME_ERROR_NONE : IME_ERROR_PERMISSION_DENIED;
 669     }
 670
 671     if (inputmethod_cynara_initialize() == false) {
 672         //LCOV_EXCL_START
 673         g_permission_allowed = false;
 674         g_checked_privilege = true;
 675         LOGE("inputmethod_cynara_initialize () == false");
 676         //LCOV_EXCL_STOP
 677         return IME_ERROR_PERMISSION_DENIED;
 678     }
 679
 680     snprintf(uid, 16, "%d", getuid());
 681     if (check_privilege(uid, IME_PRIVILEGE) == false) {
 682         LOGE("check_privilege(uid, IME_PRIVILEGE) == false. uid : %s", uid); //LCOV_EXCL_LINE
 683         ret = IME_ERROR_PERMISSION_DENIED;
 684     }
 685
 686     g_permission_allowed = (ret == IME_ERROR_NONE);
 687     g_checked_privilege = true;
 688
 689     inputmethod_cynara_finish();
 690
 691     return ret;
 692 }
 693
 694 //LCOV_EXCL_START
 695 bool g_from_dotnet = false;
 696 EXPORT_API int ime_set_dotnet_flag(bool set)
 697 {
 698     ime_error_e retVal = IME_ERROR_NONE;
 699
 700     retVal = _check_privilege();
 701     if (retVal != IME_ERROR_NONE) return retVal;
 702
 703     g_from_dotnet = set;
 704
 705     return retVal;
 706 }
 707 //LCOV_EXCL_STOP
 708
 709 EXPORT_API int ime_run(ime_callback_s *basic_cb, void *user_data)
 710 {
 711     ime_error_e retVal = IME_ERROR_NONE;
 712
 713     if (g_running) {
 714         //LCOV_EXCL_START
 715         LOGE("inputmethod main loop is already running.");
 716         return IME_ERROR_OPERATION_FAILED;
 717         //LCOV_EXCL_STOP
 718     }
 719
 720     if (!basic_cb) {
 721         LOGE("basic callbacks pointer is null.");
 722         return IME_ERROR_INVALID_PARAMETER;
 723     }
 724
 725     retVal = _check_privilege();
 726     if (retVal != IME_ERROR_NONE) return retVal;
 727
 728     g_basic_callback = *basic_cb;
 729
 730     if (!g_basic_callback.create || !g_basic_callback.terminate ||
 731         !g_basic_callback.show || !g_basic_callback.hide) {
 732         LOGE("mandatory callback functions are not set");
 733         memset(&g_basic_callback, 0, sizeof(ime_callback_s));
 734         memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
 735         return IME_ERROR_NO_CALLBACK_FUNCTION;
 736     }
 737
 738     //LCOV_EXCL_START
 739     g_user_data = user_data;
 740     g_running = true;
 741
 742     if (g_from_dotnet) {
 743         LOGD("ime_run is called from dotnet");
 744         return IME_ERROR_NONE;
 745     }
 746
 747     try {
 748         g_core.run();
 749     } catch (...) {
 750         LOGW("exception is thrown from g_core.run()\n");
 751     }
 752
 753     memset(&g_basic_callback, 0, sizeof(ime_callback_s));
 754     memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
 755     g_user_data = NULL;
 756     g_running = false;
 757
 758     return IME_ERROR_NONE;
 759     //LCOV_EXCL_STOP
 760 }
 761
 762 EXPORT_API int ime_event_set_focus_in_cb(ime_focus_in_cb callback_func, void *user_data)
 763 {
 764     ime_error_e retVal = IME_ERROR_NONE;
 765
 766     if (!callback_func) {
 767         LOGW("IME_ERROR_INVALID_PARAMETER");
 768         return IME_ERROR_INVALID_PARAMETER;
 769     }
 770
 771     retVal = _check_privilege();
 772     if (retVal != IME_ERROR_NONE) return retVal;
 773
 774     g_event_callback.focus_in = callback_func;
 775     g_event_callback.focus_in_user_data = user_data;
 776
 777     return IME_ERROR_NONE;
 778 }
 779
 780 EXPORT_API int ime_event_set_focus_out_cb(ime_focus_out_cb callback_func, void *user_data)
 781 {
 782     ime_error_e retVal = IME_ERROR_NONE;
 783
 784     if (!callback_func) {
 785         LOGW("IME_ERROR_INVALID_PARAMETER");
 786         return IME_ERROR_INVALID_PARAMETER;
 787     }
 788
 789     retVal = _check_privilege();
 790     if (retVal != IME_ERROR_NONE) return retVal;
 791
 792     g_event_callback.focus_out = callback_func;
 793     g_event_callback.focus_out_user_data = user_data;
 794
 795     return IME_ERROR_NONE;
 796 }
 797
 798 EXPORT_API int ime_event_set_surrounding_text_updated_cb(ime_surrounding_text_updated_cb callback_func, void *user_data)
 799 {
 800     ime_error_e retVal = IME_ERROR_NONE;
 801
 802     if (!callback_func) {
 803         LOGW("IME_ERROR_INVALID_PARAMETER");
 804         return IME_ERROR_INVALID_PARAMETER;
 805     }
 806
 807     retVal = _check_privilege();
 808     if (retVal != IME_ERROR_NONE) return retVal;
 809
 810     g_event_callback.surrounding_text_updated = callback_func;
 811     g_event_callback.surrounding_text_updated_user_data = user_data;
 812
 813     return IME_ERROR_NONE;
 814 }
 815
 816 EXPORT_API int ime_event_set_input_context_reset_cb(ime_input_context_reset_cb callback_func, void *user_data)
 817 {
 818     ime_error_e retVal = IME_ERROR_NONE;
 819
 820     if (!callback_func) {
 821         LOGW("IME_ERROR_INVALID_PARAMETER");
 822         return IME_ERROR_INVALID_PARAMETER;
 823     }
 824
 825     retVal = _check_privilege();
 826     if (retVal != IME_ERROR_NONE) return retVal;
 827
 828     g_event_callback.input_context_reset = callback_func;
 829     g_event_callback.input_context_reset_user_data = user_data;
 830
 831     return IME_ERROR_NONE;
 832 }
 833
 834 EXPORT_API int ime_event_set_cursor_position_updated_cb(ime_cursor_position_updated_cb callback_func, void *user_data)
 835 {
 836     ime_error_e retVal = IME_ERROR_NONE;
 837
 838     if (!callback_func) {
 839         LOGW("IME_ERROR_INVALID_PARAMETER");
 840         return IME_ERROR_INVALID_PARAMETER;
 841     }
 842
 843     retVal = _check_privilege();
 844     if (retVal != IME_ERROR_NONE) return retVal;
 845
 846     g_event_callback.cursor_position_updated = callback_func;
 847     g_event_callback.cursor_position_updated_user_data = user_data;
 848
 849     return IME_ERROR_NONE;
 850 }
 851
 852 EXPORT_API int ime_event_set_language_requested_cb(ime_language_requested_cb callback_func, void *user_data)
 853 {
 854     ime_error_e retVal = IME_ERROR_NONE;
 855
 856     if (!callback_func) {
 857         LOGW("IME_ERROR_INVALID_PARAMETER");
 858         return IME_ERROR_INVALID_PARAMETER;
 859     }
 860
 861     retVal = _check_privilege();
 862     if (retVal != IME_ERROR_NONE) return retVal;
 863
 864     g_event_callback.language_requested = callback_func;
 865     g_event_callback.language_requested_user_data = user_data;
 866
 867     return IME_ERROR_NONE;
 868 }
 869
 870 EXPORT_API int ime_event_set_language_set_cb(ime_language_set_cb callback_func, void *user_data)
 871 {
 872     ime_error_e retVal = IME_ERROR_NONE;
 873
 874     if (!callback_func) {
 875         LOGW("IME_ERROR_INVALID_PARAMETER");
 876         return IME_ERROR_INVALID_PARAMETER;
 877     }
 878
 879     retVal = _check_privilege();
 880     if (retVal != IME_ERROR_NONE) return retVal;
 881
 882     g_event_callback.language_set = callback_func;
 883     g_event_callback.language_set_user_data = user_data;
 884
 885     return IME_ERROR_NONE;
 886 }
 887
 888 EXPORT_API int ime_event_set_imdata_set_cb(ime_imdata_set_cb callback_func, void *user_data)
 889 {
 890     ime_error_e retVal = IME_ERROR_NONE;
 891
 892     if (!callback_func) {
 893         LOGW("IME_ERROR_INVALID_PARAMETER");
 894         return IME_ERROR_INVALID_PARAMETER;
 895     }
 896
 897     retVal = _check_privilege();
 898     if (retVal != IME_ERROR_NONE) return retVal;
 899
 900     g_event_callback.imdata_set = callback_func;
 901     g_event_callback.imdata_set_user_data = user_data;
 902
 903     return IME_ERROR_NONE;
 904 }
 905
 906 EXPORT_API int ime_event_set_imdata_requested_cb(ime_imdata_requested_cb callback_func, void *user_data)
 907 {
 908     ime_error_e retVal = IME_ERROR_NONE;
 909
 910     if (!callback_func) {
 911         LOGW("IME_ERROR_INVALID_PARAMETER");
 912         return IME_ERROR_INVALID_PARAMETER;
 913     }
 914
 915     retVal = _check_privilege();
 916     if (retVal != IME_ERROR_NONE) return retVal;
 917
 918     g_event_callback.imdata_requested = callback_func;
 919     g_event_callback.imdata_requested_user_data = user_data;
 920
 921     return IME_ERROR_NONE;
 922 }
 923
 924 EXPORT_API int ime_event_set_layout_set_cb(ime_layout_set_cb callback_func, void *user_data)
 925 {
 926     ime_error_e retVal = IME_ERROR_NONE;
 927
 928     if (!callback_func) {
 929         LOGW("IME_ERROR_INVALID_PARAMETER");
 930         return IME_ERROR_INVALID_PARAMETER;
 931     }
 932
 933     retVal = _check_privilege();
 934     if (retVal != IME_ERROR_NONE) return retVal;
 935
 936     g_event_callback.layout_set = callback_func;
 937     g_event_callback.layout_set_user_data = user_data;
 938
 939     return IME_ERROR_NONE;
 940 }
 941
 942 EXPORT_API int ime_event_set_return_key_type_set_cb(ime_return_key_type_set_cb callback_func, void *user_data)
 943 {
 944     ime_error_e retVal = IME_ERROR_NONE;
 945
 946     if (!callback_func) {
 947         LOGW("IME_ERROR_INVALID_PARAMETER");
 948         return IME_ERROR_INVALID_PARAMETER;
 949     }
 950
 951     retVal = _check_privilege();
 952     if (retVal != IME_ERROR_NONE) return retVal;
 953
 954     g_event_callback.return_key_type_set = callback_func;
 955     g_event_callback.return_key_type_set_user_data = user_data;
 956
 957     return IME_ERROR_NONE;
 958 }
 959
 960 EXPORT_API int ime_event_set_return_key_state_set_cb(ime_return_key_state_set_cb callback_func, void *user_data)
 961 {
 962     ime_error_e retVal = IME_ERROR_NONE;
 963
 964     if (!callback_func) {
 965         LOGW("IME_ERROR_INVALID_PARAMETER");
 966         return IME_ERROR_INVALID_PARAMETER;
 967     }
 968
 969     retVal = _check_privilege();
 970     if (retVal != IME_ERROR_NONE) return retVal;
 971
 972     g_event_callback.return_key_state_set = callback_func;
 973     g_event_callback.return_key_state_set_user_data = user_data;
 974
 975     return IME_ERROR_NONE;
 976 }
 977
 978 EXPORT_API int ime_event_set_geometry_requested_cb(ime_geometry_requested_cb callback_func, void *user_data)
 979 {
 980     ime_error_e retVal = IME_ERROR_NONE;
 981
 982     if (!callback_func) {
 983         LOGW("IME_ERROR_INVALID_PARAMETER");
 984         return IME_ERROR_INVALID_PARAMETER;
 985     }
 986
 987     retVal = _check_privilege();
 988     if (retVal != IME_ERROR_NONE) return retVal;
 989
 990     g_event_callback.geometry_requested = callback_func;
 991     g_event_callback.geometry_requested_user_data = user_data;
 992
 993     return IME_ERROR_NONE;
 994 }
 995
 996 EXPORT_API int ime_event_set_process_key_event_cb(ime_process_key_event_cb callback_func, void *user_data)
 997 {
 998     ime_error_e retVal = IME_ERROR_NONE;
 999
1000     if (!callback_func) {
1001         LOGW("IME_ERROR_INVALID_PARAMETER");
1002         return IME_ERROR_INVALID_PARAMETER;
1003     }
1004
1005     retVal = _check_privilege();
1006     if (retVal != IME_ERROR_NONE) return retVal;
1007
1008     g_event_callback.process_key_event = callback_func;
1009     g_event_callback.process_key_event_user_data = user_data;
1010
1011     return IME_ERROR_NONE;
1012 }
1013
1014 EXPORT_API int ime_event_set_process_key_event_with_keycode_cb(ime_process_key_event_with_keycode_cb callback_func, void *user_data)
1015 {
1016     ime_error_e retVal = IME_ERROR_NONE;
1017
1018     if (!callback_func) {
1019         LOGW("IME_ERROR_INVALID_PARAMETER");
1020         return IME_ERROR_INVALID_PARAMETER;
1021     }
1022
1023     retVal = _check_privilege();
1024     if (retVal != IME_ERROR_NONE) return retVal;
1025
1026     g_event_callback.process_key_event_with_keycode = callback_func;
1027     g_event_callback.process_key_event_with_keycode_user_data = user_data;
1028
1029     return IME_ERROR_NONE;
1030 }
1031
1032 EXPORT_API int ime_event_set_display_language_changed_cb(ime_display_language_changed_cb callback_func, void *user_data)
1033 {
1034     ime_error_e retVal = IME_ERROR_NONE;
1035
1036     if (!callback_func) {
1037         LOGW("IME_ERROR_INVALID_PARAMETER");
1038         return IME_ERROR_INVALID_PARAMETER;
1039     }
1040
1041     retVal = _check_privilege();
1042     if (retVal != IME_ERROR_NONE) return retVal;
1043
1044     g_event_callback.display_language_changed = callback_func;
1045     g_event_callback.display_language_changed_user_data = user_data;
1046
1047     return IME_ERROR_NONE;
1048 }
1049
1050 EXPORT_API int ime_event_set_rotation_degree_changed_cb(ime_rotation_degree_changed_cb callback_func, void *user_data)
1051 {
1052     ime_error_e retVal = IME_ERROR_NONE;
1053
1054     if (!callback_func) {
1055         LOGW("IME_ERROR_INVALID_PARAMETER");
1056         return IME_ERROR_INVALID_PARAMETER;
1057     }
1058
1059     retVal = _check_privilege();
1060     if (retVal != IME_ERROR_NONE) return retVal;
1061
1062     g_event_callback.rotation_degree_changed = callback_func;
1063     g_event_callback.rotation_degree_changed_user_data = user_data;
1064
1065     return IME_ERROR_NONE;
1066 }
1067
1068 EXPORT_API int ime_event_set_accessibility_state_changed_cb(ime_accessibility_state_changed_cb callback_func, void *user_data)
1069 {
1070     ime_error_e retVal = IME_ERROR_NONE;
1071
1072     if (!callback_func) {
1073         LOGW("IME_ERROR_INVALID_PARAMETER");
1074         return IME_ERROR_INVALID_PARAMETER;
1075     }
1076
1077     retVal = _check_privilege();
1078     if (retVal != IME_ERROR_NONE) return retVal;
1079
1080     g_event_callback.accessibility_state_changed = callback_func;
1081     g_event_callback.accessibility_state_changed_user_data = user_data;
1082
1083     return IME_ERROR_NONE;
1084 }
1085
1086 EXPORT_API int ime_event_set_option_window_created_cb(ime_option_window_created_cb callback_func, void *user_data)
1087 {
1088     ime_error_e retVal = IME_ERROR_NONE;
1089
1090     if (!callback_func) {
1091         LOGW("IME_ERROR_INVALID_PARAMETER");
1092         return IME_ERROR_INVALID_PARAMETER;
1093     }
1094
1095     retVal = _check_privilege();
1096     if (retVal != IME_ERROR_NONE) return retVal;
1097
1098     g_event_callback.option_window_created = callback_func;
1099     g_event_callback.option_window_created_user_data = user_data;
1100
1101     return IME_ERROR_NONE;
1102 }
1103
1104 EXPORT_API int ime_event_set_option_window_destroyed_cb(ime_option_window_destroyed_cb callback_func, void *user_data)
1105 {
1106     ime_error_e retVal = IME_ERROR_NONE;
1107
1108     if (!callback_func) {
1109         LOGW("IME_ERROR_INVALID_PARAMETER");
1110         return IME_ERROR_INVALID_PARAMETER;
1111     }
1112
1113     retVal = _check_privilege();
1114     if (retVal != IME_ERROR_NONE) return retVal;
1115
1116     g_event_callback.option_window_destroyed = callback_func;
1117     g_event_callback.option_window_destroyed_user_data = user_data;
1118
1119     return IME_ERROR_NONE;
1120 }
1121
1122 //LCOV_EXCL_START
1123 EXPORT_API int ime_event_set_caps_mode_changed_cb(ime_caps_mode_changed_cb callback_func, void *user_data)
1124 {
1125     ime_error_e retVal = IME_ERROR_NONE;
1126
1127     if (!callback_func) {
1128         LOGW("IME_ERROR_INVALID_PARAMETER");
1129         return IME_ERROR_INVALID_PARAMETER;
1130     }
1131
1132     retVal = _check_privilege();
1133     if (retVal != IME_ERROR_NONE) return retVal;
1134
1135     g_event_callback.caps_mode_changed = callback_func;
1136     g_event_callback.caps_mode_changed_user_data = user_data;
1137
1138     return IME_ERROR_NONE;
1139 }
1140
1141 EXPORT_API int ime_event_set_candidate_show_cb(ime_candidate_show_cb callback_func, void *user_data)
1142 {
1143     ime_error_e retVal = IME_ERROR_NONE;
1144
1145     if (!callback_func) {
1146         LOGW("IME_ERROR_INVALID_PARAMETER");
1147         return IME_ERROR_INVALID_PARAMETER;
1148     }
1149
1150     retVal = _check_privilege();
1151     if (retVal != IME_ERROR_NONE) return retVal;
1152
1153     g_event_callback.candidate_show = callback_func;
1154     g_event_callback.candidate_show_user_data = user_data;
1155
1156     return IME_ERROR_NONE;
1157 }
1158
1159 EXPORT_API int ime_event_set_candidate_hide_cb(ime_candidate_hide_cb callback_func, void *user_data)
1160 {
1161     ime_error_e retVal = IME_ERROR_NONE;
1162
1163     if (!callback_func) {
1164         LOGW("IME_ERROR_INVALID_PARAMETER");
1165         return IME_ERROR_INVALID_PARAMETER;
1166     }
1167
1168     retVal = _check_privilege();
1169     if (retVal != IME_ERROR_NONE) return retVal;
1170
1171     g_event_callback.candidate_hide = callback_func;
1172     g_event_callback.candidate_hide_user_data = user_data;
1173
1174     return IME_ERROR_NONE;
1175 }
1176
1177 EXPORT_API int ime_event_set_lookup_table_changed_cb(ime_lookup_table_changed_cb callback_func, void *user_data)
1178 {
1179     ime_error_e retVal = IME_ERROR_NONE;
1180
1181     if (!callback_func) {
1182         LOGW("IME_ERROR_INVALID_PARAMETER");
1183         return IME_ERROR_INVALID_PARAMETER;
1184     }
1185
1186     retVal = _check_privilege();
1187     if (retVal != IME_ERROR_NONE) return retVal;
1188
1189     g_event_callback.lookup_table_changed = callback_func;
1190     g_event_callback.lookup_table_changed_user_data = user_data;
1191
1192     return IME_ERROR_NONE;
1193 }
1194 //LCOV_EXCL_STOP
1195
1196 EXPORT_API int ime_send_key_event(ime_key_code_e keycode, ime_key_mask_e keymask, bool forward_key)
1197 {
1198     ime_error_e retVal = IME_ERROR_NONE;
1199
1200     if (!g_running) {
1201         LOGW("IME_ERROR_NOT_RUNNING");
1202         return IME_ERROR_NOT_RUNNING;
1203     }
1204
1205     //LCOV_EXCL_START
1206     retVal = _check_privilege();
1207     if (retVal != IME_ERROR_NONE) return retVal;
1208
1209     if (forward_key)
1210         g_core.forward_key_event(-1, NULL, (sclu32)keycode, (sclu16)keymask);
1211     else
1212         g_core.send_key_event(-1, NULL, (sclu32)keycode, (sclu16)keymask);
1213     //LCOV_EXCL_STOP
1214
1215     return IME_ERROR_NONE;
1216 }
1217
1218 EXPORT_API int ime_commit_string(const char *str)
1219 {
1220     ime_error_e retVal = IME_ERROR_NONE;
1221
1222     if (!str) {
1223         LOGW("IME_ERROR_INVALID_PARAMETER");
1224         return IME_ERROR_INVALID_PARAMETER;
1225     }
1226
1227     if (!g_running) {
1228         LOGW("IME_ERROR_NOT_RUNNING");
1229         return IME_ERROR_NOT_RUNNING;
1230     }
1231
1232     //LCOV_EXCL_START
1233     retVal = _check_privilege();
1234     if (retVal != IME_ERROR_NONE) return retVal;
1235
1236     SECURE_LOGI("commit string : %s", str);
1237     g_core.commit_string(-1, NULL, str);
1238
1239     return IME_ERROR_NONE;
1240     //LCOV_EXCL_STOP
1241 }
1242
1243 EXPORT_API int ime_show_preedit_string(void)
1244 {
1245     ime_error_e retVal = IME_ERROR_NONE;
1246
1247     if (!g_running) {
1248         LOGW("IME_ERROR_NOT_RUNNING");
1249         return IME_ERROR_NOT_RUNNING;
1250     }
1251
1252     //LCOV_EXCL_START
1253     retVal = _check_privilege();
1254     if (retVal != IME_ERROR_NONE) return retVal;
1255
1256     g_core.show_preedit_string(-1, NULL);
1257
1258     return IME_ERROR_NONE;
1259     //LCOV_EXCL_STOP
1260 }
1261
1262 EXPORT_API int ime_hide_preedit_string(void)
1263 {
1264     ime_error_e retVal = IME_ERROR_NONE;
1265
1266     if (!g_running) {
1267         LOGW("IME_ERROR_NOT_RUNNING");
1268         return IME_ERROR_NOT_RUNNING;
1269     }
1270
1271     //LCOV_EXCL_START
1272     retVal = _check_privilege();
1273     if (retVal != IME_ERROR_NONE) return retVal;
1274
1275     g_core.hide_preedit_string(-1, NULL);
1276
1277     return IME_ERROR_NONE;
1278     //LCOV_EXCL_STOP
1279 }
1280
1281 EXPORT_API int ime_update_preedit_string(const char *str, Eina_List *attrs)
1282 {
1283     ime_error_e retVal = IME_ERROR_NONE;
1284
1285     if (!str) {
1286         LOGW("IME_ERROR_INVALID_PARAMETER");
1287         return IME_ERROR_INVALID_PARAMETER;
1288     }
1289
1290     if (!g_running) {
1291         LOGW("IME_ERROR_NOT_RUNNING");
1292         return IME_ERROR_NOT_RUNNING;
1293     }
1294
1295     //LCOV_EXCL_START
1296     retVal = _check_privilege();
1297     if (retVal != IME_ERROR_NONE) return retVal;
1298
1299     scim::AttributeList attrv;
1300     void *data = NULL;
1301     ime_preedit_attribute *attr = NULL;
1302
1303     if (attrs) {
1304         EINA_LIST_FREE(attrs, data) {
1305             attr = (ime_preedit_attribute *)data;
1306             if (attr) {
1307                 attrv.push_back(scim::Attribute(attr->start, attr->length, (scim::AttributeType)attr->type, attr->value));
1308                 free(attr);
1309             }
1310         }
1311     }
1312
1313     SECURE_LOGI("preedit string : '%s'", str);
1314     g_core.update_preedit_string(-1, NULL, str, attrv);
1315
1316     return IME_ERROR_NONE;
1317     //LCOV_EXCL_STOP
1318 }
1319
1320 EXPORT_API int ime_request_surrounding_text(int maxlen_before, int maxlen_after)
1321 {
1322     ime_error_e retVal = IME_ERROR_NONE;
1323
1324     if (!g_event_callback.surrounding_text_updated) {
1325         LOGW("IME_ERROR_NO_CALLBACK_FUNCTION");
1326         return IME_ERROR_NO_CALLBACK_FUNCTION;
1327     }
1328
1329     if (!g_running) {
1330         LOGW("IME_ERROR_NOT_RUNNING");
1331         return IME_ERROR_NOT_RUNNING;
1332     }
1333
1334     //LCOV_EXCL_START
1335     retVal = _check_privilege();
1336     if (retVal != IME_ERROR_NONE) return retVal;
1337
1338     g_core.get_surrounding_text(NULL, maxlen_before, maxlen_after);
1339
1340     return IME_ERROR_NONE;
1341     //LCOV_EXCL_STOP
1342 }
1343
1344 EXPORT_API int ime_delete_surrounding_text(int offset, int len)
1345 {
1346     ime_error_e retVal = IME_ERROR_NONE;
1347
1348     if (len <= 0) {
1349         LOGW("IME_ERROR_INVALID_PARAMETER");
1350         return IME_ERROR_INVALID_PARAMETER;
1351     }
1352
1353     if (!g_running) {
1354         LOGW("IME_ERROR_NOT_RUNNING");
1355         return IME_ERROR_NOT_RUNNING;
1356     }
1357
1358     //LCOV_EXCL_START
1359     retVal = _check_privilege();
1360     if (retVal != IME_ERROR_NONE) return retVal;
1361
1362     LOGI("offset: %d, len : %d", offset, len);
1363     g_core.delete_surrounding_text(offset, len);
1364
1365     return IME_ERROR_NONE;
1366     //LCOV_EXCL_STOP
1367 }
1368
1369 EXPORT_API int ime_get_surrounding_text(int maxlen_before, int maxlen_after, char **text, int *cursor_pos)
1370 {
1371     ime_error_e retVal = IME_ERROR_NONE;
1372
1373     if (!text || !cursor_pos) {
1374         LOGW("IME_ERROR_INVALID_PARAMETER");
1375         return IME_ERROR_INVALID_PARAMETER;
1376     }
1377
1378     if (!g_running) {
1379         LOGW("IME_ERROR_NOT_RUNNING");
1380         return IME_ERROR_NOT_RUNNING;
1381     }
1382
1383     //LCOV_EXCL_START
1384     retVal = _check_privilege();
1385     if (retVal != IME_ERROR_NONE) return retVal;
1386
1387     int cursor = 0;
1388
1389     int ret = g_core.get_surrounding_text(maxlen_before, maxlen_after, text, cursor);
1390     if (ret == -1) {
1391         LOGW("IME_ERROR_OUR_OF_MEMORY");
1392         return IME_ERROR_OUT_OF_MEMORY;
1393     }
1394
1395     if (cursor_pos)
1396         *cursor_pos = cursor;
1397
1398     return IME_ERROR_NONE;
1399     //LCOV_EXCL_STOP
1400 }
1401
1402 EXPORT_API int ime_set_selection(int start, int end)
1403 {
1404     ime_error_e retVal = IME_ERROR_NONE;
1405
1406     if (start < 0) {
1407         LOGW("IME_ERROR_INVALID_PARAMETER");
1408         return IME_ERROR_INVALID_PARAMETER;
1409     }
1410
1411     if (!g_running) {
1412         LOGW("IME_ERROR_NOT_RUNNING");
1413         return IME_ERROR_NOT_RUNNING;
1414     }
1415
1416     //LCOV_EXCL_START
1417     retVal = _check_privilege();
1418     if (retVal != IME_ERROR_NONE) return retVal;
1419
1420     LOGI("start: %d, end : %d", start, end);
1421     g_core.set_selection(start, end);
1422
1423     return IME_ERROR_NONE;
1424     //LCOV_EXCL_STOP
1425 }
1426
1427 EXPORT_API int ime_get_selected_text(char **text)
1428 {
1429     ime_error_e retVal = IME_ERROR_NONE;
1430
1431     if (!text) {
1432         LOGW("IME_ERROR_INVALID_PARAMETER");
1433         return IME_ERROR_INVALID_PARAMETER;
1434     }
1435
1436     if (!g_running) {
1437         LOGW("IME_ERROR_NOT_RUNNING");
1438         return IME_ERROR_NOT_RUNNING;
1439     }
1440
1441     //LCOV_EXCL_START
1442     retVal = _check_privilege();
1443     if (retVal != IME_ERROR_NONE) return retVal;
1444
1445     g_core.get_selection_text(text);
1446
1447     return IME_ERROR_NONE;
1448     //LCOV_EXCL_STOP
1449 }
1450
1451 EXPORT_API Evas_Object* ime_get_main_window(void)
1452 {
1453     ime_error_e retVal = IME_ERROR_NONE;
1454
1455     Evas_Object *win = NULL;
1456
1457     retVal = _check_privilege();
1458     if (retVal != IME_ERROR_NONE) {
1459         //LCOV_EXCL_START
1460         LOGE("_check_privilege returned %d.", retVal);
1461         set_last_result(retVal);
1462         return NULL;
1463         //LCOV_EXCL_STOP
1464     }
1465
1466     if (!g_running) {
1467         set_last_result(IME_ERROR_NOT_RUNNING);
1468         LOGW("IME_ERROR_NOT_RUNNING");
1469         return NULL;
1470     }
1471
1472     //LCOV_EXCL_START
1473     win = static_cast<Evas_Object*>(g_core.get_main_window());
1474     if (win) {
1475         set_last_result(IME_ERROR_NONE);
1476     } else {
1477         set_last_result(IME_ERROR_OPERATION_FAILED);
1478         LOGW("IME_ERROR_OPERATION_FAILED");
1479     }
1480
1481     return win;
1482     //LCOV_EXCL_STOP
1483 }
1484
1485 EXPORT_API int ime_set_size(int portrait_width, int portrait_height, int landscape_width, int landscape_height)
1486 {
1487     ime_error_e retVal = IME_ERROR_NONE;
1488
1489     SclSize portrait_size, landscape_size;
1490
1491     if (portrait_width < 1 || portrait_height < 1 || landscape_width < 1 || landscape_height < 1) {
1492         LOGW("IME_ERROR_INVALID_PARAMETER");
1493         return IME_ERROR_INVALID_PARAMETER;
1494     }
1495
1496     if (!g_running) {
1497         LOGW("IME_ERROR_NOT_RUNNING");
1498         return IME_ERROR_NOT_RUNNING;
1499     }
1500
1501     //LCOV_EXCL_START
1502     retVal = _check_privilege();
1503     if (retVal != IME_ERROR_NONE) return retVal;
1504
1505     portrait_size.width = portrait_width;
1506     portrait_size.height = portrait_height;
1507
1508     landscape_size.width = landscape_width;
1509     landscape_size.height = landscape_height;
1510
1511     g_core.set_keyboard_size_hints(portrait_size, landscape_size);
1512
1513     return IME_ERROR_NONE;
1514     //LCOV_EXCL_STOP
1515 }
1516
1517 EXPORT_API int ime_create_option_window(void)
1518 {
1519     ime_error_e retVal = IME_ERROR_NONE;
1520
1521     if (!g_event_callback.option_window_created || !g_event_callback.option_window_destroyed) {
1522         LOGW("ime_create_option_window_cb() and ime_destroy_option_window_cb() callback functions are not set.");
1523         return IME_ERROR_NO_CALLBACK_FUNCTION;
1524     }
1525
1526     if (!g_running) {
1527         LOGW("IME_ERROR_NOT_RUNNING");
1528         return IME_ERROR_NOT_RUNNING;
1529     }
1530
1531     //LCOV_EXCL_START
1532     retVal = _check_privilege();
1533     if (retVal != IME_ERROR_NONE) return retVal;
1534
1535     if (g_core.create_option_window()) {
1536         return IME_ERROR_NONE;
1537     } else {
1538         LOGW("IME_ERROR_OPERATION_FAILED");
1539         return IME_ERROR_OPERATION_FAILED;
1540     }
1541     //LCOV_EXCL_STOP
1542 }
1543
1544 EXPORT_API int ime_destroy_option_window(Evas_Object *window)
1545 {
1546     ime_error_e retVal = IME_ERROR_NONE;
1547
1548     if (!g_event_callback.option_window_created || !g_event_callback.option_window_destroyed) {
1549         LOGW("ime_create_option_window_cb() and ime_destroy_option_window_cb() callback functions are not set.");
1550         return IME_ERROR_NO_CALLBACK_FUNCTION;
1551     }
1552
1553     if (!window) {
1554         LOGW("Window pointer is null.");
1555         return IME_ERROR_INVALID_PARAMETER;
1556     }
1557
1558     if (!g_running) {
1559         LOGW("IME_ERROR_NOT_RUNNING");
1560         return IME_ERROR_NOT_RUNNING;
1561     }
1562
1563     //LCOV_EXCL_START
1564     retVal = _check_privilege();
1565     if (retVal != IME_ERROR_NONE) return retVal;
1566
1567     g_core.destroy_option_window(window);
1568
1569     return IME_ERROR_NONE;
1570     //LCOV_EXCL_STOP
1571 }
1572
1573 //LCOV_EXCL_START
1574 EXPORT_API int ime_set_imengine(const char *engine_id)
1575 {
1576     ime_error_e retVal = IME_ERROR_NONE;
1577
1578     if (!engine_id) {
1579         LOGW("IME_ERROR_INVALID_PARAMETER");
1580         return IME_ERROR_INVALID_PARAMETER;
1581     }
1582
1583     retVal = _check_privilege();
1584     if (retVal != IME_ERROR_NONE) return retVal;
1585
1586     g_core.set_keyboard_ise_by_uuid(engine_id);
1587
1588     return IME_ERROR_NONE;
1589 }
1590
1591 EXPORT_API int ime_flush_imengine(void)
1592 {
1593     ime_error_e retVal = IME_ERROR_NONE;
1594
1595     if (!g_running) {
1596         LOGW("IME_ERROR_NOT_RUNNING");
1597         return IME_ERROR_NOT_RUNNING;
1598     }
1599
1600     retVal = _check_privilege();
1601     if (retVal != IME_ERROR_NONE) return retVal;
1602
1603     g_core.flush_keyboard_ise();
1604
1605     return IME_ERROR_NONE;
1606 }
1607
1608 EXPORT_API int ime_send_imengine_event(int command, unsigned int value)
1609 {
1610     ime_error_e retVal = IME_ERROR_NONE;
1611
1612     if (!g_running) {
1613         LOGW("IME_ERROR_NOT_RUNNING");
1614         return IME_ERROR_NOT_RUNNING;
1615     }
1616
1617     retVal = _check_privilege();
1618     if (retVal != IME_ERROR_NONE) return retVal;
1619
1620     g_core.send_imengine_event(-1, NULL, command, value);
1621
1622     return IME_ERROR_NONE;
1623 }
1624
1625 EXPORT_API int ime_reset_imengine(void)
1626 {
1627     ime_error_e retVal = IME_ERROR_NONE;
1628
1629     if (!g_running) {
1630         LOGW("IME_ERROR_NOT_RUNNING");
1631         return IME_ERROR_NOT_RUNNING;
1632     }
1633
1634     retVal = _check_privilege();
1635     if (retVal != IME_ERROR_NONE) return retVal;
1636
1637     g_core.reset_keyboard_ise();
1638
1639     return IME_ERROR_NONE;
1640 }
1641
1642 EXPORT_API int ime_update_input_context(unsigned int type, unsigned int value)
1643 {
1644     ime_error_e retVal = IME_ERROR_NONE;
1645
1646     if (!g_running) {
1647         LOGW("IME_ERROR_NOT_RUNNING");
1648         return IME_ERROR_NOT_RUNNING;
1649     }
1650
1651     retVal = _check_privilege();
1652     if (retVal != IME_ERROR_NONE) return retVal;
1653
1654     g_core.update_input_context(type, value);
1655
1656     return IME_ERROR_NONE;
1657 }
1658 //LCOV_EXCL_STOP
1659
1660 EXPORT_API int ime_request_hide(void)
1661 {
1662     ime_error_e retVal = IME_ERROR_NONE;
1663
1664     if (!g_running) {
1665         LOGW("IME_ERROR_NOT_RUNNING");
1666         return IME_ERROR_NOT_RUNNING;
1667     }
1668
1669     //LCOV_EXCL_START
1670     retVal = _check_privilege();
1671     if (retVal != IME_ERROR_NONE) return retVal;
1672
1673     g_core.request_ise_hide();
1674
1675     return IME_ERROR_NONE;
1676     //LCOV_EXCL_STOP
1677 }
1678
1679 //LCOV_EXCL_START
1680 EXPORT_API int ime_initialize(void)
1681 {
1682     ime_error_e retVal = IME_ERROR_NONE;
1683
1684     retVal = _check_privilege();
1685     if (retVal != IME_ERROR_NONE) return retVal;
1686
1687     g_core.init();
1688     g_running = false;
1689
1690     return retVal;
1691 }
1692
1693 EXPORT_API int ime_prepare(void)
1694 {
1695     ime_error_e retVal = IME_ERROR_NONE;
1696
1697     if (g_running) {
1698         LOGE("inputmethod main loop is already running.");
1699         return IME_ERROR_OPERATION_FAILED;
1700     }
1701
1702     retVal = _check_privilege();
1703     if (retVal != IME_ERROR_NONE) return retVal;
1704
1705     g_core.prepare();
1706
1707     g_running = true;
1708
1709     return retVal;
1710 }
1711
1712 EXPORT_API int ime_finalize(void)
1713 {
1714     ime_error_e retVal = IME_ERROR_NONE;
1715
1716     retVal = _check_privilege();
1717     if (retVal != IME_ERROR_NONE) return retVal;
1718
1719     g_core.fini();
1720     g_running = false;
1721     memset(&g_basic_callback, 0, sizeof(ime_callback_s));
1722     memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
1723     g_user_data = NULL;
1724
1725     return retVal;
1726 }
1727
1728 EXPORT_API int ime_select_candidate(unsigned int index)
1729 {
1730     ime_error_e retVal = IME_ERROR_NONE;
1731
1732     if (!g_running) {
1733         LOGW("IME_ERROR_NOT_RUNNING");
1734         return IME_ERROR_NOT_RUNNING;
1735     }
1736
1737     retVal = _check_privilege();
1738     if (retVal != IME_ERROR_NONE) return retVal;
1739
1740     g_core.select_candidate(index);
1741
1742     return IME_ERROR_NONE;
1743 }
1744 //LCOV_EXCL_STOP
1745
1746 EXPORT_API int ime_send_private_command(const char *command)
1747 {
1748     ime_error_e retVal = IME_ERROR_NONE;
1749
1750     if (!command) {
1751         LOGW("IME_ERROR_INVALID_PARAMETER");
1752         return IME_ERROR_INVALID_PARAMETER;
1753     }
1754
1755     if (!g_running) {
1756         LOGW("IME_ERROR_NOT_RUNNING");
1757         return IME_ERROR_NOT_RUNNING;
1758     }
1759
1760     //LCOV_EXCL_START
1761     retVal = _check_privilege();
1762     if (retVal != IME_ERROR_NONE) return retVal;
1763
1764     g_core.send_private_command(command);
1765
1766     return IME_ERROR_NONE;
1767     //LCOV_EXCL_STOP
1768 }
1769
1770 EXPORT_API int ime_commit_content(const char *content, const char *description, const char *mime_type)
1771 {
1772     ime_error_e retVal = IME_ERROR_NONE;
1773
1774     if (!content || !description || !mime_type) {
1775         LOGW("IME_ERROR_INVALID_PARAMETER");
1776         return IME_ERROR_INVALID_PARAMETER;
1777     }
1778
1779     retVal = _check_privilege();
1780     if (retVal != IME_ERROR_NONE) return retVal;
1781
1782     if (!g_running) {
1783         LOGW("IME_ERROR_NOT_RUNNING");
1784         return IME_ERROR_NOT_RUNNING;
1785     }
1786
1787     //LCOV_EXCL_START
1788     LOGI("content : '%s', description : '%s', mime_type : '%s'", content, description, mime_type);
1789     g_core.commit_content(content, description, mime_type);
1790
1791     return IME_ERROR_NONE;
1792     //LCOV_EXCL_STOP
1793 }
1794
1795 EXPORT_API int ime_context_get_layout(ime_context_h context, Ecore_IMF_Input_Panel_Layout *layout)
1796 {
1797     ime_error_e retVal = IME_ERROR_NONE;
1798
1799     if (!context || !layout) {
1800         LOGW("IME_ERROR_INVALID_PARAMETER");
1801         return IME_ERROR_INVALID_PARAMETER;
1802     }
1803
1804     retVal = _check_privilege();
1805     if (retVal != IME_ERROR_NONE) return retVal;
1806
1807     if (!g_running) {
1808         LOGW("IME_ERROR_NOT_RUNNING");
1809         return IME_ERROR_NOT_RUNNING;
1810     }
1811
1812     //LCOV_EXCL_START
1813     *layout = context->layout;
1814
1815     return IME_ERROR_NONE;
1816     //LCOV_EXCL_STOP
1817 }
1818
1819 EXPORT_API int ime_context_get_layout_variation(ime_context_h context, ime_layout_variation_e *layout_variation)
1820 {
1821     ime_error_e retVal = IME_ERROR_NONE;
1822
1823     if (!context || !layout_variation) {
1824         LOGW("IME_ERROR_INVALID_PARAMETER");
1825         return IME_ERROR_INVALID_PARAMETER;
1826     }
1827
1828     retVal = _check_privilege();
1829     if (retVal != IME_ERROR_NONE) return retVal;
1830
1831     if (!g_running) {
1832         LOGW("IME_ERROR_NOT_RUNNING");
1833         return IME_ERROR_NOT_RUNNING;
1834     }
1835
1836     //LCOV_EXCL_START
1837     *layout_variation = static_cast<ime_layout_variation_e>(context->layout_variation);
1838
1839     return IME_ERROR_NONE;
1840     //LCOV_EXCL_STOP
1841 }
1842
1843 EXPORT_API int ime_context_get_cursor_position(ime_context_h context, int *cursor_pos)
1844 {
1845     ime_error_e retVal = IME_ERROR_NONE;
1846
1847     if (!context || !cursor_pos) {
1848         LOGW("IME_ERROR_INVALID_PARAMETER");
1849         return IME_ERROR_INVALID_PARAMETER;
1850     }
1851
1852     retVal = _check_privilege();
1853     if (retVal != IME_ERROR_NONE) return retVal;
1854
1855     if (!g_running) {
1856         LOGW("IME_ERROR_NOT_RUNNING");
1857         return IME_ERROR_NOT_RUNNING;
1858     }
1859
1860     //LCOV_EXCL_START
1861     *cursor_pos = context->cursor_pos;
1862
1863     return IME_ERROR_NONE;
1864     //LCOV_EXCL_STOP
1865 }
1866
1867 EXPORT_API int ime_context_get_autocapital_type(ime_context_h context, Ecore_IMF_Autocapital_Type *autocapital_type)
1868 {
1869     ime_error_e retVal = IME_ERROR_NONE;
1870
1871     if (!context || !autocapital_type) {
1872         LOGW("IME_ERROR_INVALID_PARAMETER");
1873         return IME_ERROR_INVALID_PARAMETER;
1874     }
1875
1876     retVal = _check_privilege();
1877     if (retVal != IME_ERROR_NONE) return retVal;
1878
1879     if (!g_running) {
1880         LOGW("IME_ERROR_NOT_RUNNING");
1881         return IME_ERROR_NOT_RUNNING;
1882     }
1883
1884     //LCOV_EXCL_START
1885     *autocapital_type = context->autocapital_type;
1886
1887     return IME_ERROR_NONE;
1888     //LCOV_EXCL_STOP
1889 }
1890
1891 EXPORT_API int ime_context_get_return_key_type(ime_context_h context, Ecore_IMF_Input_Panel_Return_Key_Type *return_key_type)
1892 {
1893     ime_error_e retVal = IME_ERROR_NONE;
1894
1895     if (!context || !return_key_type) {
1896         LOGW("IME_ERROR_INVALID_PARAMETER");
1897         return IME_ERROR_INVALID_PARAMETER;
1898     }
1899
1900     retVal = _check_privilege();
1901     if (retVal != IME_ERROR_NONE) return retVal;
1902
1903     if (!g_running) {
1904         LOGW("IME_ERROR_NOT_RUNNING");
1905         return IME_ERROR_NOT_RUNNING;
1906     }
1907
1908     //LCOV_EXCL_START
1909     *return_key_type = context->return_key_type;
1910
1911     return IME_ERROR_NONE;
1912     //LCOV_EXCL_STOP
1913 }
1914
1915 EXPORT_API int ime_context_get_return_key_state(ime_context_h context, bool *return_key_state)
1916 {
1917     ime_error_e retVal = IME_ERROR_NONE;
1918
1919     if (!context || !return_key_state) {
1920         LOGW("IME_ERROR_INVALID_PARAMETER");
1921         return IME_ERROR_INVALID_PARAMETER;
1922     }
1923
1924     retVal = _check_privilege();
1925     if (retVal != IME_ERROR_NONE) return retVal;
1926
1927     if (!g_running) {
1928         LOGW("IME_ERROR_NOT_RUNNING");
1929         return IME_ERROR_NOT_RUNNING;
1930     }
1931
1932     //LCOV_EXCL_START
1933     *return_key_state = static_cast<bool>(context->return_key_disabled);
1934
1935     return IME_ERROR_NONE;
1936     //LCOV_EXCL_STOP
1937 }
1938
1939 EXPORT_API int ime_context_get_prediction_mode(ime_context_h context, bool *prediction_mode)
1940 {
1941     ime_error_e retVal = IME_ERROR_NONE;
1942
1943     if (!context || !prediction_mode) {
1944         LOGW("IME_ERROR_INVALID_PARAMETER");
1945         return IME_ERROR_INVALID_PARAMETER;
1946     }
1947
1948     retVal = _check_privilege();
1949     if (retVal != IME_ERROR_NONE) return retVal;
1950
1951     if (!g_running) {
1952         LOGW("IME_ERROR_NOT_RUNNING");
1953         return IME_ERROR_NOT_RUNNING;
1954     }
1955
1956     //LCOV_EXCL_START
1957     *prediction_mode = static_cast<bool>(context->prediction_allow);
1958
1959     return IME_ERROR_NONE;
1960     //LCOV_EXCL_STOP
1961 }
1962
1963 EXPORT_API int ime_context_get_password_mode(ime_context_h context, bool *password_mode)
1964 {
1965     ime_error_e retVal = IME_ERROR_NONE;
1966
1967     if (!context || !password_mode) {
1968         LOGW("IME_ERROR_INVALID_PARAMETER");
1969         return IME_ERROR_INVALID_PARAMETER;
1970     }
1971
1972     retVal = _check_privilege();
1973     if (retVal != IME_ERROR_NONE) return retVal;
1974
1975     if (!g_running) {
1976         LOGW("IME_ERROR_NOT_RUNNING");
1977         return IME_ERROR_NOT_RUNNING;
1978     }
1979
1980     //LCOV_EXCL_START
1981     *password_mode = static_cast<bool>(context->password_mode);
1982
1983     return IME_ERROR_NONE;
1984     //LCOV_EXCL_STOP
1985 }
1986
1987 EXPORT_API int ime_context_get_input_hint(ime_context_h context, Ecore_IMF_Input_Hints *input_hint)
1988 {
1989     ime_error_e retVal = IME_ERROR_NONE;
1990
1991     if (!context || !input_hint) {
1992         LOGW("IME_ERROR_INVALID_PARAMETER");
1993         return IME_ERROR_INVALID_PARAMETER;
1994     }
1995
1996     retVal = _check_privilege();
1997     if (retVal != IME_ERROR_NONE) return retVal;
1998
1999     if (!g_running) {
2000         LOGW("IME_ERROR_NOT_RUNNING");
2001         return IME_ERROR_NOT_RUNNING;
2002     }
2003
2004     //LCOV_EXCL_START
2005     *input_hint = context->input_hint;
2006
2007     return IME_ERROR_NONE;
2008     //LCOV_EXCL_STOP
2009 }
2010
2011 EXPORT_API int ime_context_get_bidi_direction(ime_context_h context, Ecore_IMF_BiDi_Direction *bidi)
2012 {
2013     ime_error_e retVal = IME_ERROR_NONE;
2014
2015     if (!context || !bidi) {
2016         LOGW("IME_ERROR_INVALID_PARAMETER");
2017         return IME_ERROR_INVALID_PARAMETER;
2018     }
2019
2020     retVal = _check_privilege();
2021     if (retVal != IME_ERROR_NONE) return retVal;
2022
2023     if (!g_running) {
2024         LOGW("IME_ERROR_NOT_RUNNING");
2025         return IME_ERROR_NOT_RUNNING;
2026     }
2027
2028     //LCOV_EXCL_START
2029     *bidi = context->bidi_direction;
2030
2031     return IME_ERROR_NONE;
2032     //LCOV_EXCL_STOP
2033 }
2034
2035 EXPORT_API int ime_context_get_language(ime_context_h context, Ecore_IMF_Input_Panel_Lang *language)
2036 {
2037     ime_error_e retVal = IME_ERROR_NONE;
2038
2039     if (!context || !language) {
2040         LOGW("IME_ERROR_INVALID_PARAMETER");
2041         return IME_ERROR_INVALID_PARAMETER;
2042     }
2043
2044     retVal = _check_privilege();
2045     if (retVal != IME_ERROR_NONE) return retVal;
2046
2047     if (!g_running) {
2048         LOGW("IME_ERROR_NOT_RUNNING");
2049         return IME_ERROR_NOT_RUNNING;
2050     }
2051
2052     //LCOV_EXCL_START
2053     *language = context->language;
2054
2055     return IME_ERROR_NONE;
2056     //LCOV_EXCL_STOP
2057 }
2058
2059 //LCOV_EXCL_START
2060 EXPORT_API int ime_context_get_caps_mode(ime_context_h context, bool *caps_mode)
2061 {
2062     ime_error_e retVal = IME_ERROR_NONE;
2063
2064     if (!context || !caps_mode) {
2065         LOGW("IME_ERROR_INVALID_PARAMETER");
2066         return IME_ERROR_INVALID_PARAMETER;
2067     }
2068
2069     retVal = _check_privilege();
2070     if (retVal != IME_ERROR_NONE) return retVal;
2071
2072     if (!g_running) {
2073         LOGW("IME_ERROR_NOT_RUNNING");
2074         return IME_ERROR_NOT_RUNNING;
2075     }
2076
2077     *caps_mode = static_cast<bool>(context->caps_mode);
2078
2079     return IME_ERROR_NONE;
2080 }
2081 //LCOV_EXCL_STOP
2082
2083 EXPORT_API int ime_device_info_get_name(ime_device_info_h dev_info, char **dev_name)
2084 {
2085     ime_error_e retVal = IME_ERROR_NONE;
2086
2087     if (!dev_info || !dev_name) {
2088         LOGW("IME_ERROR_INVALID_PARAMETER");
2089         return IME_ERROR_INVALID_PARAMETER;
2090     }
2091
2092     retVal = _check_privilege();
2093     if (retVal != IME_ERROR_NONE) return retVal;
2094
2095     if (!g_running) {
2096         LOGW("IME_ERROR_NOT_RUNNING");
2097         return IME_ERROR_NOT_RUNNING;
2098     }
2099
2100     //LCOV_EXCL_START
2101     if (!dev_info->dev_name)
2102         *dev_name = strdup("");
2103     else
2104         *dev_name = strdup(dev_info->dev_name);
2105
2106     return IME_ERROR_NONE;
2107     //LCOV_EXCL_STOP
2108 }
2109
2110 EXPORT_API int ime_device_info_get_class(ime_device_info_h dev_info, Ecore_IMF_Device_Class *dev_class)
2111 {
2112     ime_error_e retVal = IME_ERROR_NONE;
2113
2114     if (!dev_info || !dev_class) {
2115         LOGW("IME_ERROR_INVALID_PARAMETER");
2116         return IME_ERROR_INVALID_PARAMETER;
2117     }
2118
2119     retVal = _check_privilege();
2120     if (retVal != IME_ERROR_NONE) return retVal;
2121
2122     if (!g_running) {
2123         LOGW("IME_ERROR_NOT_RUNNING");
2124         return IME_ERROR_NOT_RUNNING;
2125     }
2126
2127     //LCOV_EXCL_START
2128     *dev_class = dev_info->dev_class;
2129
2130     return IME_ERROR_NONE;
2131     //LCOV_EXCL_STOP
2132 }
2133
2134 EXPORT_API int ime_device_info_get_subclass(ime_device_info_h dev_info, Ecore_IMF_Device_Subclass *dev_subclass)
2135 {
2136     ime_error_e retVal = IME_ERROR_NONE;
2137
2138     if (!dev_info || !dev_subclass) {
2139         LOGW("IME_ERROR_INVALID_PARAMETER");
2140         return IME_ERROR_INVALID_PARAMETER;
2141     }
2142
2143     retVal = _check_privilege();
2144     if (retVal != IME_ERROR_NONE) return retVal;
2145
2146     if (!g_running) {
2147         LOGW("IME_ERROR_NOT_RUNNING");
2148         return IME_ERROR_NOT_RUNNING;
2149     }
2150
2151     //LCOV_EXCL_START
2152     *dev_subclass = dev_info->dev_subclass;
2153
2154     return IME_ERROR_NONE;
2155     //LCOV_EXCL_STOP
2156 }
2157
2158 //LCOV_EXCL_START
2159 EXPORT_API int ime_event_set_process_input_device_event_cb(ime_process_input_device_event_cb callback_func, void *user_data)
2160 {
2161     ime_error_e retVal = IME_ERROR_NONE;
2162
2163     if (!callback_func) {
2164         LOGW("IME_ERROR_INVALID_PARAMETER");
2165         return IME_ERROR_INVALID_PARAMETER;
2166     }
2167
2168     retVal = _check_privilege();
2169     if (retVal != IME_ERROR_NONE) return retVal;
2170
2171     g_event_callback.process_input_device_event = callback_func;
2172     g_event_callback.process_input_device_event_user_data = user_data;
2173
2174     return IME_ERROR_NONE;
2175 }
2176
2177 EXPORT_API int ime_event_unset_process_input_device_event_cb(void)
2178 {
2179     ime_error_e retVal = IME_ERROR_NONE;
2180
2181     retVal = _check_privilege();
2182     if (retVal != IME_ERROR_NONE) return retVal;
2183
2184     g_event_callback.process_input_device_event = NULL;
2185     g_event_callback.process_input_device_event_user_data = NULL;
2186
2187     return IME_ERROR_NONE;
2188 }
2189
2190 /* Functions for Rotary input device event */
2191 EXPORT_API int ime_input_device_rotary_get_direction(ime_input_device_event_h event_handle, ime_input_device_rotary_direction_e *direction)
2192 {
2193     ime_error_e retVal = IME_ERROR_NONE;
2194
2195     if (!event_handle || !direction) {
2196         LOGW("IME_ERROR_INVALID_PARAMETER");
2197         return IME_ERROR_INVALID_PARAMETER;
2198     }
2199
2200     ime_device_event_s *device_event = static_cast<ime_device_event_s*>(event_handle);
2201     if (device_event->device_type != IME_INPUT_DEVICE_TYPE_ROTARY) {
2202         LOGW("IME_ERROR_INVALID_PARAMETER");
2203         return IME_ERROR_INVALID_PARAMETER;
2204     }
2205
2206     retVal = _check_privilege();
2207     if (retVal != IME_ERROR_NONE) return retVal;
2208
2209     if (!g_running) {
2210         LOGW("IME_ERROR_OPERATION_FAILED");
2211         return IME_ERROR_OPERATION_FAILED;
2212     }
2213
2214     //LCOV_EXCL_START
2215     Ecore_Event_Detent_Rotate *rotary_device_event =
2216         static_cast<Ecore_Event_Detent_Rotate*>(device_event->event_data);
2217     if (rotary_device_event) {
2218         if (rotary_device_event->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) {
2219             *direction = IME_INPUT_DEVICE_ROTARY_DIRECTION_CLOCKWISE;
2220         } else if (rotary_device_event->direction == ECORE_DETENT_DIRECTION_COUNTER_CLOCKWISE) {
2221             *direction = IME_INPUT_DEVICE_ROTARY_DIRECTION_COUNTER_CLOCKWISE;
2222         }
2223     }
2224
2225     return IME_ERROR_NONE;
2226     //LCOV_EXCL_STOP
2227 }
2228 //LCOV_EXCL_STOP
2229
2230 EXPORT_API int ime_event_set_prediction_hint_set_cb(ime_prediction_hint_set_cb callback_func, void *user_data)
2231 {
2232     ime_error_e retVal = IME_ERROR_NONE;
2233
2234     if (!callback_func) {
2235         LOGW("IME_ERROR_INVALID_PARAMETER");
2236         return IME_ERROR_INVALID_PARAMETER;
2237     }
2238
2239     retVal = _check_privilege();
2240     if (retVal != IME_ERROR_NONE) return retVal;
2241
2242     g_event_callback.prediction_hint_set = callback_func;
2243     g_event_callback.prediction_hint_set_user_data = user_data;
2244
2245     return IME_ERROR_NONE;
2246 }
2247
2248 EXPORT_API int ime_event_set_mime_type_set_request_cb(ime_mime_type_set_request_cb callback_func, void *user_data)
2249 {
2250     ime_error_e retVal = IME_ERROR_NONE;
2251
2252     if (!callback_func) {
2253         LOGW("IME_ERROR_INVALID_PARAMETER");
2254         return IME_ERROR_INVALID_PARAMETER;
2255     }
2256
2257     retVal = _check_privilege();
2258     if (retVal != IME_ERROR_NONE) return retVal;
2259
2260     g_event_callback.mime_type_set = callback_func;
2261     g_event_callback.mime_type_set_user_data = user_data;
2262
2263     return IME_ERROR_NONE;
2264 }
2265
2266 EXPORT_API int ime_set_floating_mode(bool floating_mode)
2267 {
2268     ime_error_e retVal = IME_ERROR_NONE;
2269
2270     retVal = _check_privilege();
2271     if (retVal != IME_ERROR_NONE) return retVal;
2272
2273     if (!g_running) {
2274         LOGW("IME_ERROR_NOT_RUNNING");
2275         return IME_ERROR_NOT_RUNNING;
2276     }
2277
2278     //LCOV_EXCL_START
2279     g_core.set_floating_mode(floating_mode);
2280
2281     return IME_ERROR_NONE;
2282     //LCOV_EXCL_STOP
2283 }
2284
2285 EXPORT_API int ime_set_floating_drag_start(void)
2286 {
2287     ime_error_e retVal = IME_ERROR_NONE;
2288
2289     retVal = _check_privilege();
2290     if (retVal != IME_ERROR_NONE) return retVal;
2291
2292     if (!g_running) {
2293         LOGW("IME_ERROR_NOT_RUNNING");
2294         return IME_ERROR_NOT_RUNNING;
2295     }
2296
2297     //LCOV_EXCL_START
2298     g_core.set_floating_drag_enabled(true);
2299
2300     return IME_ERROR_NONE;
2301     //LCOV_EXCL_STOP
2302 }
2303
2304 EXPORT_API int ime_set_floating_drag_end(void)
2305 {
2306     ime_error_e retVal = IME_ERROR_NONE;
2307
2308     retVal = _check_privilege();
2309     if (retVal != IME_ERROR_NONE) return retVal;
2310
2311     if (!g_running) {
2312         LOGW("IME_ERROR_NOT_RUNNING");
2313         return IME_ERROR_NOT_RUNNING;
2314     }
2315
2316     //LCOV_EXCL_START
2317     g_core.set_floating_drag_enabled(false);
2318
2319     return IME_ERROR_NONE;
2320     //LCOV_EXCL_STOP
2321 }
2322
2323 //LCOV_EXCL_START
2324 EXPORT_API int ime_set_window_creation_defer_flag(bool flag)
2325 {
2326     ime_error_e retVal = IME_ERROR_NONE;
2327
2328     retVal = _check_privilege();
2329     if (retVal != IME_ERROR_NONE) return retVal;
2330
2331     g_core.set_window_creation_defer_flag(flag);
2332
2333     return IME_ERROR_NONE;
2334 }
2335 //LCOV_EXCL_STOP
2336
2337 EXPORT_API int ime_event_set_prediction_hint_data_set_cb(ime_prediction_hint_data_set_cb callback_func, void *user_data)
2338 {
2339     ime_error_e retVal = IME_ERROR_NONE;
2340
2341     if (!callback_func) {
2342         LOGW("IME_ERROR_INVALID_PARAMETER");
2343         return IME_ERROR_INVALID_PARAMETER;
2344     }
2345
2346     retVal = _check_privilege();
2347     if (retVal != IME_ERROR_NONE) return retVal;
2348
2349     g_event_callback.prediction_hint_data_set = callback_func;
2350     g_event_callback.prediction_hint_data_set_user_data = user_data;
2351
2352     return IME_ERROR_NONE;
2353 }
2354
2355 //LCOV_EXCL_START
2356 EXPORT_API int ime_event_set_optimization_hint_set_cb(ime_optimization_hint_set_cb callback_func, void *user_data)
2357 {
2358     LOGD("");
2359     ime_error_e retVal = IME_ERROR_NONE;
2360
2361     if (!callback_func) {
2362         LOGW("IME_ERROR_INVALID_PARAMETER");
2363         return IME_ERROR_INVALID_PARAMETER;
2364     }
2365
2366     LOGD("");
2367     retVal = _check_privilege();
2368     if (retVal != IME_ERROR_NONE) return retVal;
2369
2370     LOGD("");
2371     g_event_callback.optimization_hint_set = callback_func;
2372     g_event_callback.optimization_hint_set_user_data = user_data;
2373
2374     return IME_ERROR_NONE;
2375 }
2376
2377 EXPORT_API int ime_event_set_process_key_event_with_imengine_cb(ime_process_key_event_with_imengine_cb callback_func, void *user_data)
2378 {
2379     LOGD("");
2380     ime_error_e retVal = IME_ERROR_NONE;
2381
2382     if (!callback_func) {
2383         LOGW("IME_ERROR_INVALID_PARAMETER");
2384         return IME_ERROR_INVALID_PARAMETER;
2385     }
2386
2387     retVal = _check_privilege();
2388     if (retVal != IME_ERROR_NONE) return retVal;
2389
2390     g_event_callback.process_key_event_with_imengine = callback_func;
2391     g_event_callback.process_key_event_with_imengine_user_data = user_data;
2392
2393     return IME_ERROR_NONE;
2394 }
2395
2396 EXPORT_API int ime_event_set_autocapital_type_set_cb(ime_autocapital_type_set_cb callback_func, void *user_data)
2397 {
2398     LOGD("");
2399     ime_error_e retVal = IME_ERROR_NONE;
2400
2401     if (!callback_func) {
2402         LOGW("IME_ERROR_INVALID_PARAMETER");
2403         return IME_ERROR_INVALID_PARAMETER;
2404     }
2405
2406     retVal = _check_privilege();
2407     if (retVal != IME_ERROR_NONE) return retVal;
2408
2409     g_event_callback.autocapital_type_set = callback_func;
2410     g_event_callback.autocapital_type_set_user_data = user_data;
2411
2412     return IME_ERROR_NONE;
2413 }
2414
2415 EXPORT_API int ime_event_set_prediction_allow_set_cb(ime_prediction_allow_set_cb callback_func, void *user_data)
2416 {
2417     LOGD("");
2418     ime_error_e retVal = IME_ERROR_NONE;
2419
2420     if (!callback_func) {
2421         LOGW("IME_ERROR_INVALID_PARAMETER");
2422         return IME_ERROR_INVALID_PARAMETER;
2423     }
2424
2425     retVal = _check_privilege();
2426     if (retVal != IME_ERROR_NONE) return retVal;
2427
2428     g_event_callback.prediction_allow_set = callback_func;
2429     g_event_callback.prediction_allow_set_user_data = user_data;
2430
2431     return IME_ERROR_NONE;
2432 }
2433
2434 EXPORT_API int ime_event_set_trigger_property_set_cb(ime_trigger_property_set_cb callback_func, void *user_data)
2435 {
2436     LOGD("");
2437     ime_error_e retVal = IME_ERROR_NONE;
2438
2439     if (!callback_func) {
2440         LOGW("IME_ERROR_INVALID_PARAMETER");
2441         return IME_ERROR_INVALID_PARAMETER;
2442     }
2443
2444     retVal = _check_privilege();
2445     if (retVal != IME_ERROR_NONE) return retVal;
2446
2447     g_event_callback.trigger_property_set = callback_func;
2448     g_event_callback.trigger_property_set_user_data = user_data;
2449
2450     return IME_ERROR_NONE;
2451 }
2452
2453 EXPORT_API int ime_event_set_candidate_more_window_show_cb(ime_candidate_more_window_show_cb callback_func, void *user_data)
2454 {
2455     LOGD("");
2456     ime_error_e retVal = IME_ERROR_NONE;
2457
2458     if (!callback_func) {
2459         LOGW("IME_ERROR_INVALID_PARAMETER");
2460         return IME_ERROR_INVALID_PARAMETER;
2461     }
2462
2463     retVal = _check_privilege();
2464     if (retVal != IME_ERROR_NONE) return retVal;
2465
2466     g_event_callback.candidate_more_window_show = callback_func;
2467     g_event_callback.candidate_more_window_show_user_data = user_data;
2468
2469     return IME_ERROR_NONE;
2470 }
2471
2472 EXPORT_API int ime_event_set_candidate_more_window_hide_cb(ime_candidate_more_window_hide_cb callback_func, void *user_data)
2473 {
2474     LOGD("");
2475     ime_error_e retVal = IME_ERROR_NONE;
2476
2477     if (!callback_func) {
2478         LOGW("IME_ERROR_INVALID_PARAMETER");
2479         return IME_ERROR_INVALID_PARAMETER;
2480     }
2481
2482     retVal = _check_privilege();
2483     if (retVal != IME_ERROR_NONE) return retVal;
2484
2485     g_event_callback.candidate_more_window_hide = callback_func;
2486     g_event_callback.candidate_more_window_hide_user_data = user_data;
2487
2488     return IME_ERROR_NONE;
2489 }
2490
2491 EXPORT_API int ime_event_set_aux_select_cb(ime_aux_select_cb callback_func, void *user_data)
2492 {
2493     LOGD("");
2494     ime_error_e retVal = IME_ERROR_NONE;
2495
2496     if (!callback_func) {
2497         LOGW("IME_ERROR_INVALID_PARAMETER");
2498         return IME_ERROR_INVALID_PARAMETER;
2499     }
2500
2501     retVal = _check_privilege();
2502     if (retVal != IME_ERROR_NONE) return retVal;
2503
2504     g_event_callback.aux_select = callback_func;
2505     g_event_callback.aux_select_user_data = user_data;
2506
2507     return IME_ERROR_NONE;
2508 }
2509
2510 EXPORT_API int ime_event_set_candidate_select_cb(ime_candidate_select_cb callback_func, void *user_data)
2511 {
2512     LOGD("");
2513     ime_error_e retVal = IME_ERROR_NONE;
2514
2515     if (!callback_func) {
2516         LOGW("IME_ERROR_INVALID_PARAMETER");
2517         return IME_ERROR_INVALID_PARAMETER;
2518     }
2519
2520     retVal = _check_privilege();
2521     if (retVal != IME_ERROR_NONE) return retVal;
2522
2523     g_event_callback.candidate_select = callback_func;
2524     g_event_callback.candidate_select_user_data = user_data;
2525
2526     return IME_ERROR_NONE;
2527 }
2528
2529 EXPORT_API int ime_event_set_candidate_table_page_up_cb(ime_candidate_table_page_up_cb callback_func, void *user_data)
2530 {
2531     LOGD("");
2532     ime_error_e retVal = IME_ERROR_NONE;
2533
2534     if (!callback_func) {
2535         LOGW("IME_ERROR_INVALID_PARAMETER");
2536         return IME_ERROR_INVALID_PARAMETER;
2537     }
2538
2539     retVal = _check_privilege();
2540     if (retVal != IME_ERROR_NONE) return retVal;
2541
2542     g_event_callback.candidate_table_page_up = callback_func;
2543     g_event_callback.candidate_table_page_up_user_data = user_data;
2544
2545     return IME_ERROR_NONE;
2546 }
2547
2548 EXPORT_API int ime_event_set_candidate_table_page_down_cb(ime_candidate_table_page_down_cb callback_func, void *user_data)
2549 {
2550     LOGD("");
2551     ime_error_e retVal = IME_ERROR_NONE;
2552
2553     if (!callback_func) {
2554         LOGW("IME_ERROR_INVALID_PARAMETER");
2555         return IME_ERROR_INVALID_PARAMETER;
2556     }
2557
2558     retVal = _check_privilege();
2559     if (retVal != IME_ERROR_NONE) return retVal;
2560
2561     g_event_callback.candidate_table_page_down = callback_func;
2562     g_event_callback.candidate_table_page_down_user_data = user_data;
2563
2564     return IME_ERROR_NONE;
2565 }
2566
2567 EXPORT_API int ime_event_set_candidate_table_page_size_chaned_cb(ime_candidate_table_page_size_chaned_cb callback_func, void *user_data)
2568 {
2569     LOGD("");
2570     ime_error_e retVal = IME_ERROR_NONE;
2571
2572     if (!callback_func) {
2573         LOGW("IME_ERROR_INVALID_PARAMETER");
2574         return IME_ERROR_INVALID_PARAMETER;
2575     }
2576
2577     retVal = _check_privilege();
2578     if (retVal != IME_ERROR_NONE) return retVal;
2579
2580     g_event_callback.candidate_table_page_size_chaned = callback_func;
2581     g_event_callback.candidate_table_page_size_chaned_user_data = user_data;
2582
2583     return IME_ERROR_NONE;
2584 }
2585
2586 EXPORT_API int ime_event_set_candidate_item_layout_set_cb(ime_candidate_item_layout_set_cb callback_func, void *user_data)
2587 {
2588     LOGD("");
2589     ime_error_e retVal = IME_ERROR_NONE;
2590
2591     if (!callback_func) {
2592         LOGW("IME_ERROR_INVALID_PARAMETER");
2593         return IME_ERROR_INVALID_PARAMETER;
2594     }
2595
2596     retVal = _check_privilege();
2597     if (retVal != IME_ERROR_NONE) return retVal;
2598
2599     g_event_callback.candidate_item_layout_set = callback_func;
2600     g_event_callback.candidate_item_layout_set_user_data = user_data;
2601
2602     return IME_ERROR_NONE;
2603 }
2604
2605 EXPORT_API int ime_event_set_displayed_candidate_number_chaned_cb(ime_displayed_candidate_number_chaned_cb callback_func, void *user_data)
2606 {
2607     LOGD("");
2608     ime_error_e retVal = IME_ERROR_NONE;
2609
2610     if (!callback_func) {
2611         LOGW("IME_ERROR_INVALID_PARAMETER");
2612         return IME_ERROR_INVALID_PARAMETER;
2613     }
2614
2615     retVal = _check_privilege();
2616     if (retVal != IME_ERROR_NONE) return retVal;
2617
2618     g_event_callback.displayed_candidate_number_chaned = callback_func;
2619     g_event_callback.displayed_candidate_number_chaned_user_data = user_data;
2620
2621     return IME_ERROR_NONE;
2622 }
2623
2624 EXPORT_API int ime_event_set_candidate_item_long_pressed_cb(ime_candidate_item_long_pressed_cb callback_func, void *user_data)
2625 {
2626     LOGD("");
2627     ime_error_e retVal = IME_ERROR_NONE;
2628
2629     if (!callback_func) {
2630         LOGW("IME_ERROR_INVALID_PARAMETER");
2631         return IME_ERROR_INVALID_PARAMETER;
2632     }
2633
2634     retVal = _check_privilege();
2635     if (retVal != IME_ERROR_NONE) return retVal;
2636
2637     g_event_callback.candidate_item_long_pressed = callback_func;
2638     g_event_callback.candidate_item_long_pressed_user_data = user_data;
2639
2640     return IME_ERROR_NONE;
2641 }
2642
2643 EXPORT_API int ime_show_aux_string(void)
2644 {
2645     ime_error_e retVal = IME_ERROR_NONE;
2646
2647     retVal = _check_privilege();
2648     if (retVal != IME_ERROR_NONE) return retVal;
2649
2650     if (!g_running) {
2651         LOGW("IME_ERROR_NOT_RUNNING");
2652         return IME_ERROR_NOT_RUNNING;
2653     }
2654
2655     g_core.show_aux_string();
2656
2657     return IME_ERROR_NONE;
2658 }
2659
2660 EXPORT_API int ime_hide_aux_string(void)
2661 {
2662     ime_error_e retVal = IME_ERROR_NONE;
2663
2664     retVal = _check_privilege();
2665     if (retVal != IME_ERROR_NONE) return retVal;
2666
2667     if (!g_running) {
2668         LOGW("IME_ERROR_NOT_RUNNING");
2669         return IME_ERROR_NOT_RUNNING;
2670     }
2671
2672     g_core.hide_aux_string();
2673
2674     return IME_ERROR_NONE;
2675 }
2676
2677 EXPORT_API int ime_show_lookup_table(void)
2678 {
2679     ime_error_e retVal = IME_ERROR_NONE;
2680
2681     retVal = _check_privilege();
2682     if (retVal != IME_ERROR_NONE) return retVal;
2683
2684     if (!g_running) {
2685         LOGW("IME_ERROR_NOT_RUNNING");
2686         return IME_ERROR_NOT_RUNNING;
2687     }
2688
2689     g_core.show_candidate_string();
2690
2691     return IME_ERROR_NONE;
2692 }
2693
2694 EXPORT_API int ime_hide_lookup_table(void)
2695 {
2696     ime_error_e retVal = IME_ERROR_NONE;
2697
2698     retVal = _check_privilege();
2699     if (retVal != IME_ERROR_NONE) return retVal;
2700
2701     if (!g_running) {
2702         LOGW("IME_ERROR_NOT_RUNNING");
2703         return IME_ERROR_NOT_RUNNING;
2704     }
2705
2706     g_core.hide_candidate_string();
2707
2708     return IME_ERROR_NONE;
2709 }
2710
2711 EXPORT_API int ime_update_preedit_caret(int caret)
2712 {
2713     ime_error_e retVal = IME_ERROR_NONE;
2714
2715     if (caret < 0) {
2716         LOGW("IME_ERROR_INVALID_PARAMETER");
2717         return IME_ERROR_INVALID_PARAMETER;
2718     }
2719
2720     if (!g_running) {
2721         LOGW("IME_ERROR_NOT_RUNNING");
2722         return IME_ERROR_NOT_RUNNING;
2723     }
2724
2725     retVal = _check_privilege();
2726     if (retVal != IME_ERROR_NONE) return retVal;
2727
2728     g_core.update_preedit_caret(caret);
2729
2730     return IME_ERROR_NONE;
2731 }
2732
2733 EXPORT_API int ime_update_preedit_string_with_commit(const char *preedit, const char *commit, scim::AttributeList &attrs, int caret)
2734 {
2735     ime_error_e retVal = IME_ERROR_NONE;
2736
2737     if (!preedit && !commit) {
2738         LOGW("IME_ERROR_INVALID_PARAMETER");
2739         return IME_ERROR_INVALID_PARAMETER;
2740     }
2741
2742     if (!g_running) {
2743         LOGW("IME_ERROR_NOT_RUNNING");
2744         return IME_ERROR_NOT_RUNNING;
2745     }
2746
2747     retVal = _check_privilege();
2748     if (retVal != IME_ERROR_NONE) return retVal;
2749
2750     g_core.update_preedit_string_with_commit(preedit, commit, attrs, caret);
2751
2752     return IME_ERROR_NONE;
2753 }
2754
2755 EXPORT_API int ime_update_aux_string(const char *str)
2756 {
2757     ime_error_e retVal = IME_ERROR_NONE;
2758
2759     if (!str) {
2760         LOGW("IME_ERROR_INVALID_PARAMETER");
2761         return IME_ERROR_INVALID_PARAMETER;
2762     }
2763
2764     if (!g_running) {
2765         LOGW("IME_ERROR_NOT_RUNNING");
2766         return IME_ERROR_NOT_RUNNING;
2767     }
2768
2769     retVal = _check_privilege();
2770     if (retVal != IME_ERROR_NONE) return retVal;
2771
2772     g_core.update_aux_string(str);
2773
2774     return IME_ERROR_NONE;
2775 }
2776
2777 EXPORT_API int ime_recapture_string(int offset, int len, const char *preedit, const char *commit, scim::AttributeList &attrs)
2778 {
2779     ime_error_e retVal = IME_ERROR_NONE;
2780
2781     if (len < 0) {
2782         LOGW("IME_ERROR_INVALID_PARAMETER");
2783         return IME_ERROR_INVALID_PARAMETER;
2784     }
2785
2786     if (!g_running) {
2787         LOGW("IME_ERROR_NOT_RUNNING");
2788         return IME_ERROR_NOT_RUNNING;
2789     }
2790
2791     retVal = _check_privilege();
2792     if (retVal != IME_ERROR_NONE) return retVal;
2793
2794     g_core.recapture_string(offset, len, preedit, commit, attrs);
2795
2796     return IME_ERROR_NONE;
2797 }
2798
2799 EXPORT_API int ime_update_lookup_table(scim::LookupTable &table)
2800 {
2801     ime_error_e retVal = IME_ERROR_NONE;
2802
2803     if (!g_running) {
2804         LOGW("IME_ERROR_NOT_RUNNING");
2805         return IME_ERROR_NOT_RUNNING;
2806     }
2807
2808     retVal = _check_privilege();
2809     if (retVal != IME_ERROR_NONE) return retVal;
2810
2811     g_core.update_lookup_table(table);
2812
2813     return IME_ERROR_NONE;
2814 }
2815
2816 EXPORT_API int ime_register_properties(scim::PropertyList &properties)
2817 {
2818     ime_error_e retVal = IME_ERROR_NONE;
2819
2820     if (!g_running) {
2821         LOGW("IME_ERROR_NOT_RUNNING");
2822         return IME_ERROR_NOT_RUNNING;
2823     }
2824
2825     retVal = _check_privilege();
2826     if (retVal != IME_ERROR_NONE) return retVal;
2827
2828     g_core.register_properties(properties);
2829
2830     return IME_ERROR_NONE;
2831 }
2832
2833 EXPORT_API int ime_update_property(scim::Property &property)
2834 {
2835     ime_error_e retVal = IME_ERROR_NONE;
2836
2837     if (!g_running) {
2838         LOGW("IME_ERROR_NOT_RUNNING");
2839         return IME_ERROR_NOT_RUNNING;
2840     }
2841
2842     retVal = _check_privilege();
2843     if (retVal != IME_ERROR_NONE) return retVal;
2844
2845     g_core.update_property(property);
2846
2847     return IME_ERROR_NONE;
2848 }
2849
2850 EXPORT_API int ime_expand_candidate(void)
2851 {
2852     ime_error_e retVal = IME_ERROR_NONE;
2853
2854     retVal = _check_privilege();
2855     if (retVal != IME_ERROR_NONE) return retVal;
2856
2857     if (!g_running) {
2858         LOGW("IME_ERROR_NOT_RUNNING");
2859         return IME_ERROR_NOT_RUNNING;
2860     }
2861
2862     g_core.expand_candidate();
2863
2864     return IME_ERROR_NONE;
2865 }
2866
2867 EXPORT_API int ime_contract_candidate(void)
2868 {
2869     ime_error_e retVal = IME_ERROR_NONE;
2870
2871     retVal = _check_privilege();
2872     if (retVal != IME_ERROR_NONE) return retVal;
2873
2874     if (!g_running) {
2875         LOGW("IME_ERROR_NOT_RUNNING");
2876         return IME_ERROR_NOT_RUNNING;
2877     }
2878
2879     g_core.contract_candidate();
2880
2881     return IME_ERROR_NONE;
2882 }
2883
2884 EXPORT_API int ime_set_candidate_style(scim::ISF_CANDIDATE_PORTRAIT_LINE_T portrait_line, scim::ISF_CANDIDATE_MODE_T mode)
2885 {
2886     ime_error_e retVal = IME_ERROR_NONE;
2887
2888     if (portrait_line < 0 || mode < 0) {
2889         LOGW("IME_ERROR_INVALID_PARAMETER");
2890         return IME_ERROR_INVALID_PARAMETER;
2891     }
2892
2893     if (!g_running) {
2894         LOGW("IME_ERROR_NOT_RUNNING");
2895         return IME_ERROR_NOT_RUNNING;
2896     }
2897
2898     retVal = _check_privilege();
2899     if (retVal != IME_ERROR_NONE) return retVal;
2900
2901     g_core.set_candidate_style(portrait_line, mode);
2902
2903     return IME_ERROR_NONE;
2904 }
2905 //LCOV_EXCL_STOP
2906
2907 EXPORT_API int ime_update_input_panel_event(ime_event_type_e type, unsigned int value)
2908 {
2909     ime_error_e retVal = IME_ERROR_NONE;
2910
2911     if (type < IME_EVENT_TYPE_LANGUAGE || type > IME_EVENT_TYPE_GEOMETRY) {
2912         LOGW("IME_ERROR_INVALID_PARAMETER");
2913         return IME_ERROR_INVALID_PARAMETER;
2914     }
2915
2916     if (!g_running) {
2917         LOGW("IME_ERROR_NOT_RUNNING");
2918         return IME_ERROR_NOT_RUNNING;
2919     }
2920
2921     //LCOV_EXCL_START
2922     retVal = _check_privilege();
2923     if (retVal != IME_ERROR_NONE) return retVal;
2924
2925     g_core.update_input_context((sclu32)type, value);
2926
2927     return IME_ERROR_NONE;
2928     //LCOV_EXCL_STOP
2929 }
2930
2931 EXPORT_API int ime_set_candidate_visibility_state(bool visible)
2932 {
2933     ime_error_e retVal = IME_ERROR_NONE;
2934
2935     if (!g_running) {
2936         LOGW("IME_ERROR_NOT_RUNNING");
2937         return IME_ERROR_NOT_RUNNING;
2938     }
2939
2940     //LCOV_EXCL_START
2941     retVal = _check_privilege();
2942     if (retVal != IME_ERROR_NONE) return retVal;
2943
2944     if (visible)
2945         g_core.show_candidate_string();
2946     else
2947         g_core.hide_candidate_string();
2948
2949     return IME_ERROR_NONE;
2950     //LCOV_EXCL_STOP
2951 }