src/sclconnection-isf.cpp

   1 /*
   2  * Copyright (c) 2014 - 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
  18 #include "sclconnection-isf.h"
  19 #include "sclcoreimpl.h"
  20 #include <Elementary.h>
  21 #include <dlog.h>
  22
  23 #ifdef WEBSOCKET
  24 #include "legacy_support/websocket.h"
  25 extern CWebHelperAgentWebSocket g_websocket;
  26 #endif
  27
  28 using namespace scl;
  29
  30 static scim::ConfigPointer _scim_config(0);
  31
  32 /* Slot functions for calling appropriate callback functions */
  33 static void slot_exit(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
  34     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
  35     if (impl) {
  36         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
  37         if (callback) {
  38             callback->on_ise_hide(ic, ic_uuid.c_str());
  39             LOGD("call on_exit");
  40             callback->on_exit();
  41         }
  42         if (agent) {
  43             agent->update_ise_exit();
  44         }
  45     }
  46     LOGD("exit");
  47     elm_exit();
  48 }
  49
  50 static void slot_attach_input_context(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
  51     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
  52     if (impl) {
  53         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
  54         if (callback) {
  55             callback->on_attach_input_context(ic, ic_uuid.c_str());
  56         }
  57     }
  58 }
  59
  60 static void slot_detach_input_context(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
  61     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
  62     if (impl) {
  63         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
  64         if (callback) {
  65             callback->on_detach_input_context(ic, ic_uuid.c_str());
  66         }
  67     }
  68 }
  69
  70 static void slot_reload_config(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
  71     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
  72     if (impl) {
  73         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
  74         if (callback) {
  75             callback->on_reload_config(ic, ic_uuid.c_str());
  76         }
  77     }
  78 }
  79
  80 static void slot_update_screen(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, int screen_number) {
  81     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
  82     if (impl) {
  83         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
  84         if (callback) {
  85             //callback->on_update_screen(ic, ic_uuid.c_str(), screen_number);
  86         }
  87     }
  88 }
  89
  90 static void slot_update_spot_location(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, int x, int y) {
  91     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
  92     if (impl) {
  93         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
  94         if (callback) {
  95             callback->on_update_spot_location(ic, ic_uuid.c_str(), x, y);
  96         }
  97     }
  98 }
  99
 100 static void slot_update_cursor_position(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, int cursor_pos) {
 101     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 102     if (impl) {
 103         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 104         if (callback) {
 105             callback->on_update_cursor_position(ic, ic_uuid.c_str(), cursor_pos);
 106 #ifdef WEBSOCKET
 107             g_websocket.on_update_cursor_position(ic, cursor_pos);
 108 #endif
 109         }
 110     }
 111 }
 112
 113 static void slot_update_surrounding_text(const scim::HelperAgent *agent, int ic, const scim::String &text, int cursor) {
 114     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 115     if (impl) {
 116         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 117         if (callback) {
 118             callback->on_update_surrounding_text(ic, text.c_str(), cursor);
 119 #ifdef WEBSOCKET
 120             g_websocket.on_update_surrounding_text(ic, text.c_str(), cursor);
 121 #endif
 122         }
 123     }
 124 }
 125
 126 static void slot_trigger_property(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, const scim::String &property) {
 127     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 128     if (impl) {
 129         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 130         if (callback) {
 131             //callback->on_trigger_property(ic, ic_uuid.c_str(), property.c_str());
 132         }
 133     }
 134 }
 135
 136 static void slot_focus_out(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
 137     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 138     if (impl) {
 139         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 140         if (callback) {
 141             callback->on_focus_out(ic, ic_uuid.c_str());
 142 #ifdef WEBSOCKET
 143             g_websocket.on_focus_out(ic);
 144 #endif
 145         }
 146     }
 147 }
 148
 149 static void slot_focus_in(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
 150     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 151     if (impl) {
 152         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 153         if (callback) {
 154             callback->on_focus_in(ic, ic_uuid.c_str());
 155 #ifdef WEBSOCKET
 156             g_websocket.on_focus_in(ic);
 157 #endif
 158         }
 159     }
 160 }
 161
 162 static void slot_ise_show(const scim::HelperAgent *agent, int ic, char *buf, size_t &len) {
 163     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 164     if (impl) {
 165         /* Make sure the appropriate keyboard ise was selected -> is this really necessary? */
 166         //impl->set_keyboard_ise_by_uuid(impl->get_keyboard_ise_uuid().c_str());
 167
 168         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 169         if (callback) {
 170             /* Check if effect is enabled */
 171             Ise_Context ise_context;
 172             memset(&ise_context, 0x00, sizeof(ise_context));
 173
 174             if (len >= sizeof(Ise_Context)) {
 175                 memcpy(&ise_context, buf, sizeof(ise_context));
 176
 177                 if (ise_context.imdata_size > 0) {
 178                     char imdata[1024] = {0};
 179                     memcpy((void *)imdata, buf + sizeof(ise_context), ise_context.imdata_size);
 180                     callback->on_set_imdata(imdata, ise_context.imdata_size);
 181                 }
 182
 183                 if (len > (sizeof(Ise_Context) + ise_context.imdata_size))
 184                     callback->on_set_mime_type(buf + sizeof(ise_context) + ise_context.imdata_size);
 185             } else {
 186                 LOGD("\n-=-= WARNING - buf %p len %zu size %zu\n", buf, len, sizeof(ise_context));
 187             }
 188             CSCLCoreUI* ui = impl->get_core_ui();
 189             if (ui) {
 190                 ui->process_keyboard_ui_state_change(KEYBOARD_UI_STATE_WILL_SHOW);
 191             }
 192             callback->on_ise_show(ic, impl->get_screen_rotation_degree(), ise_context);
 193             if (ui) {
 194                 ui->process_keyboard_ui_state_change(KEYBOARD_UI_STATE_DID_SHOW);
 195             }
 196
 197 #ifdef WEBSOCKET
 198             g_websocket.on_set_layout(ise_context.layout);
 199             g_websocket.on_update_cursor_position(ic, ise_context.cursor_pos);
 200             g_websocket.on_show(ic);
 201 #endif
 202         }
 203     }
 204 }
 205
 206 static void slot_ise_hide(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
 207     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 208     if (impl) {
 209         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 210         if (callback) {
 211             CSCLCoreUI* ui = impl->get_core_ui();
 212             if (ui) {
 213                 ui->process_keyboard_ui_state_change(KEYBOARD_UI_STATE_WILL_HIDE);
 214             }
 215             callback->on_ise_hide(ic, ic_uuid.c_str());
 216             if (ui) {
 217                 ui->process_keyboard_ui_state_change(KEYBOARD_UI_STATE_DID_HIDE);
 218             }
 219
 220 #ifdef WEBSOCKET
 221             g_websocket.on_hide(ic);
 222 #endif
 223         }
 224     }
 225 }
 226
 227 static void slot_get_geometry(const scim::HelperAgent *agent, struct scim::rectinfo &info) {
 228     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 229     if (impl) {
 230         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 231         if (callback) {
 232             callback->on_get_geometry(&(info.pos_x), &(info.pos_y), &(info.width), &(info.height));
 233         }
 234     }
 235 }
 236
 237 static void slot_set_mode(const scim::HelperAgent *agent, scim::uint32 &mode) {
 238     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 239     if (impl) {
 240         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 241         if (callback) {
 242             callback->on_set_mode(mode);
 243         }
 244     }
 245 }
 246
 247 static void slot_set_language(const scim::HelperAgent *agent, scim::uint32 &language) {
 248     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 249     if (impl) {
 250         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 251         if (callback) {
 252             callback->on_set_language(language);
 253 #ifdef WEBSOCKET
 254             g_websocket.on_set_language(language);
 255 #endif
 256         }
 257     }
 258 }
 259
 260 static void slot_set_imdata(const scim::HelperAgent *agent, char *buf, size_t &len) {
 261     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 262     if (impl) {
 263         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 264         if (callback) {
 265             scl32 _len = static_cast<scl32>(reinterpret_cast<size_t>(len) & 0xffffffff);
 266             callback->on_set_imdata(buf, _len);
 267 #ifdef WEBSOCKET
 268             g_websocket.on_set_imdata(buf, len);
 269 #endif
 270         }
 271     }
 272 }
 273
 274 static void slot_get_imdata(const scim::HelperAgent *, char **buf, size_t &len) {
 275     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 276     if (impl) {
 277         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 278         if (callback) {
 279             sclu32 _len = 0;
 280             callback->on_get_imdata(buf, &_len);
 281 #ifdef WEBSOCKET
 282             g_websocket.on_get_imdata(buf, &_len);
 283 #endif
 284             len = _len;
 285         }
 286     }
 287 }
 288
 289 static void slot_get_language_locale(const scim::HelperAgent *, int ic, char **locale) {
 290     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 291     if (impl) {
 292         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 293         if (callback) {
 294             callback->on_get_language_locale(ic, locale);
 295         }
 296     }
 297 }
 298
 299 static void slot_set_return_key_type(const scim::HelperAgent *agent, scim::uint32 &type) {
 300     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 301     if (impl) {
 302         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 303         if (callback) {
 304             callback->on_set_return_key_type(type);
 305 #ifdef WEBSOCKET
 306             g_websocket.on_set_return_key_type(type);
 307 #endif
 308         }
 309     }
 310 }
 311
 312 static void slot_get_return_key_type(const scim::HelperAgent *agent, scim::uint32 &type) {
 313     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 314     if (impl) {
 315         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 316         if (callback) {
 317             callback->on_get_return_key_type(&type);
 318 #ifdef WEBSOCKET
 319             g_websocket.on_get_return_key_type(&type);
 320 #endif
 321         }
 322     }
 323 }
 324
 325 static void slot_set_return_key_disable(const scim::HelperAgent *agent, scim::uint32 &disabled) {
 326     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 327     if (impl) {
 328         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 329         if (callback) {
 330             callback->on_set_return_key_disable(disabled);
 331 #ifdef WEBSOCKET
 332             g_websocket.on_set_return_key_disable(disabled);
 333 #endif
 334         }
 335     }
 336 }
 337
 338 static void slot_get_return_key_disable(const scim::HelperAgent *agent, scim::uint32 &disabled) {
 339     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 340     if (impl) {
 341         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 342         if (callback) {
 343             callback->on_get_return_key_disable(&disabled);
 344 #ifdef WEBSOCKET
 345             g_websocket.on_get_return_key_disable(&disabled);
 346 #endif
 347         }
 348     }
 349 }
 350
 351 static void slot_set_layout(const scim::HelperAgent *agent, scim::uint32 &layout) {
 352     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 353     if (impl) {
 354         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 355         if (callback) {
 356             callback->on_set_layout(layout);
 357 #ifdef WEBSOCKET
 358             g_websocket.on_set_layout(layout);
 359 #endif
 360         }
 361     }
 362 }
 363
 364 static void slot_get_layout(const scim::HelperAgent *agent, scim::uint32 &layout) {
 365     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 366     if (impl) {
 367         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 368         if (callback) {
 369             callback->on_get_layout(&layout);
 370 #ifdef WEBSOCKET
 371             g_websocket.on_get_layout(&layout);
 372 #endif
 373         }
 374     }
 375 }
 376
 377 static void slot_set_caps_mode(const scim::HelperAgent *agent, scim::uint32 &mode) {
 378     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 379     if (impl) {
 380         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 381         if (callback) {
 382             callback->on_set_caps_mode(mode);
 383         }
 384     }
 385 }
 386
 387 static void slot_reset_input_context(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 388     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 389     if (impl) {
 390         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 391         if (callback) {
 392             callback->on_reset_input_context(ic, uuid.c_str());
 393 #ifdef WEBSOCKET
 394             g_websocket.on_reset_input_context(ic);
 395 #endif
 396         }
 397     }
 398 }
 399
 400 static void slot_update_candidate_geometry(const scim::HelperAgent *agent, int ic, const scim::String &uuid, const scim::rectinfo &info) {
 401     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 402     if (impl) {
 403         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 404         if (callback) {
 405             callback->on_update_candidate_geometry(ic, uuid.c_str(), info.pos_x, info.pos_y, info.width, info.height);
 406         }
 407     }
 408 }
 409 static void slot_update_keyboard_ise(const scim::HelperAgent *agent, int ic, const scim::String &uuid,
 410                                                   const scim::String &ise_name, const scim::String &ise_uuid) {
 411     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 412     if (impl) {
 413         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 414         if (callback) {
 415             callback->on_update_keyboard_ise(ic, uuid.c_str(), ise_name.c_str(), ise_uuid.c_str());
 416         }
 417     }
 418 }
 419
 420 static void slot_candidate_more_window_show(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 421     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 422     if (impl) {
 423         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 424         if (callback) {
 425             callback->on_candidate_more_window_show(ic, uuid.c_str());
 426         }
 427     }
 428 }
 429
 430 static void slot_candidate_more_window_hide(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 431     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 432     if (impl) {
 433         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 434         if (callback) {
 435             callback->on_candidate_more_window_hide(ic, uuid.c_str());
 436         }
 437     }
 438 }
 439
 440 static void slot_select_aux(const scim::HelperAgent *agent, int ic, const scim::String &uuid, int index) {
 441     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 442     if (impl) {
 443         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 444         if (callback) {
 445             callback->on_select_aux(ic, uuid.c_str(), index);
 446         }
 447     }
 448 }
 449
 450 static void slot_select_candidate(const scim::HelperAgent *agent, int ic, const scim::String &uuid, int index) {
 451     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 452     if (impl) {
 453         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 454         if (callback) {
 455             callback->on_select_candidate(ic, uuid.c_str(), index);
 456         }
 457     }
 458 }
 459
 460 static void slot_candidate_table_page_up(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 461     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 462     if (impl) {
 463         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 464         if (callback) {
 465             callback->on_candidate_table_page_up(ic, uuid.c_str());
 466         }
 467     }
 468 }
 469
 470 static void slot_candidate_table_page_down(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 471     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 472     if (impl) {
 473         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 474         if (callback) {
 475             callback->on_candidate_table_page_down(ic, uuid.c_str());
 476         }
 477     }
 478 }
 479
 480 static void slot_update_candidate_table_page_size(const scim::HelperAgent *, int ic, const scim::String &uuid, int page_size) {
 481     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 482     if (impl) {
 483         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 484         if (callback) {
 485             callback->on_update_candidate_table_page_size(ic, uuid.c_str(), page_size);
 486         }
 487     }
 488 }
 489
 490 static void slot_update_lookup_table(const scim::HelperAgent *, scim::LookupTable &table) {
 491     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 492     if (impl) {
 493         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 494         if (callback) {
 495             SclCandidateTable lookup_table;
 496             lookup_table.page_size = table.get_page_size();
 497             lookup_table.current_page_start = table.get_current_page_start();
 498             lookup_table.cursor_pos = table.get_cursor_pos();
 499             lookup_table.cursor_visible = table.is_cursor_visible();
 500             lookup_table.page_size_fixed = table.is_page_size_fixed();
 501             lookup_table.candidate_labels.clear();
 502             for (int page_index = 0;page_index < lookup_table.page_size;page_index++) {
 503                 scim::WideString label = table.get_candidate_label(page_index);
 504                 lookup_table.candidate_labels.push_back(scim::utf8_wcstombs(label).c_str());
 505             }
 506
 507             int nCandidateSize = table.get_current_page_size();
 508             for (int index = 0; index < nCandidateSize; ++index) {
 509                 scim::WideString candidate_str = table.get_candidate_in_current_page(index);
 510                 lookup_table.candidate.push_back(scim::utf8_wcstombs(candidate_str).c_str());
 511             }
 512
 513             callback->on_update_lookup_table(lookup_table);
 514
 515             std::vector<scim::WideString> labels;
 516             for (unsigned int loop = 0;loop < lookup_table.candidate_labels.size();loop++) {
 517                 labels.push_back(scim::utf8_mbstowcs(lookup_table.candidate_labels.at(loop).c_str()));
 518             }
 519             table.set_candidate_labels(labels);
 520         }
 521     }
 522 }
 523
 524 static void slot_select_associate(const scim::HelperAgent *agent, int ic, const scim::String &uuid, int index) {
 525     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 526     if (impl) {
 527         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 528         if (callback) {
 529             callback->on_select_associate(ic, uuid.c_str(), index);
 530         }
 531     }
 532 }
 533
 534 static void slot_associate_table_page_up(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 535     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 536     if (impl) {
 537         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 538         if (callback) {
 539             callback->on_associate_table_page_up(ic, uuid.c_str());
 540         }
 541     }
 542 }
 543
 544 static void slot_associate_table_page_down(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 545     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 546     if (impl) {
 547         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 548         if (callback) {
 549             callback->on_associate_table_page_down(ic, uuid.c_str());
 550         }
 551     }
 552 }
 553
 554 static void slot_update_associate_table_page_size(const scim::HelperAgent *, int ic, const scim::String &uuid, int page_size) {
 555     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 556     if (impl) {
 557         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 558         if (callback) {
 559             callback->on_update_associate_table_page_size(ic, uuid.c_str(), page_size);
 560         }
 561     }
 562 }
 563
 564 static void slot_show_ise_option_window(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 565     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 566     if (impl) {
 567         CSCLCoreUI *core_ui = impl->get_core_ui();
 568         if (core_ui) {
 569             LOGD("slot_show_ise_option_window() called!!!\n");
 570             core_ui->create_option_window(OPTION_WINDOW_TYPE_SETTING_APPLICATION);
 571         }
 572     }
 573 }
 574
 575 static void slot_resume_ise_option_window(const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
 576     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 577     if (impl) {
 578         CSCLCoreUI *core_ui = impl->get_core_ui();
 579         if (core_ui) {
 580             LOGD("slot_resume_ise_option_window() called!!!\n");
 581             core_ui->show_option_window(OPTION_WINDOW_TYPE_SETTING_APPLICATION);
 582         }
 583     }
 584 }
 585
 586 static void slot_check_ise_option_window(const scim::HelperAgent *agent, sclu32 &avail) {
 587     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 588     if (impl) {
 589         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 590         if (callback) {
 591             callback->on_check_option_window_availability(reinterpret_cast<sclboolean *>(&avail));
 592         }
 593     }
 594 }
 595
 596 static void slot_process_key_event(const scim::HelperAgent *agent, scim::KeyEvent &key, scim::uint32 &ret) {
 597     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 598     if (impl) {
 599         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 600         if (callback) {
 601             callback->on_process_key_event(key, &ret);
 602 #ifdef WEBSOCKETweb_ret
 603             g_websocket.on_process_key_event(key.code, key.mask, key.layout, &ret);
 604 #endif
 605         }
 606     }
 607 }
 608
 609 static void slot_candidate_show(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
 610     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 611     if (impl) {
 612         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 613         if (callback) {
 614             callback->on_candidate_show(ic, ic_uuid.c_str());
 615         }
 616     }
 617 }
 618
 619 static void slot_candidate_hide(const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
 620     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 621     if (impl) {
 622         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 623         if (callback) {
 624             callback->on_candidate_hide(ic, ic_uuid.c_str());
 625         }
 626     }
 627 }
 628
 629 static void slot_process_input_device_event(const scim::HelperAgent *agent, scim::uint32 &type, char *data, size_t &len, scim::uint32 &ret) {
 630     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 631     if (impl) {
 632         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 633         if (callback) {
 634             /* Input Device Event callback is available in versions after 1.1 */
 635             if (check_interface_version(callback, 1, 1)) {
 636                 callback->on_process_input_device_event(type, data, len, &ret);
 637             }
 638         }
 639     }
 640 }
 641
 642 static void slot_set_prediction_hint(const scim::HelperAgent *agent, const scim::String &prediction_hint) {
 643     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 644     if (impl) {
 645         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 646         if (callback) {
 647             callback->on_set_prediction_hint(prediction_hint.c_str());
 648         }
 649     }
 650 }
 651
 652 static void slot_set_mime_type(const scim::HelperAgent *agent, const scim::String &mime_type) {
 653     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 654     if (impl) {
 655         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 656         if (callback) {
 657             callback->on_set_mime_type(mime_type.c_str());
 658         }
 659     }
 660 }
 661
 662 static void slot_set_prediction_hint_data(const scim::HelperAgent *agent, int ic, const scim::String &key, const scim::String &value) {
 663     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 664     if (impl) {
 665         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 666         if (callback) {
 667             SECURE_LOGD("key : %s, value : %s\n", key.c_str(), value.c_str());
 668             callback->on_set_prediction_hint_data(key.c_str(), value.c_str());
 669         }
 670     }
 671 }
 672
 673 static void slot_set_optimization_hint(const scim::HelperAgent *agent, scim::uint32 &hint) {
 674     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 675     if (impl) {
 676         ISCLCoreEventCallback *callback = impl->get_core_event_callback();
 677         if (callback) {
 678             SECURE_LOGD("hint : %d\n", hint);
 679             callback->on_set_optimization_hint(hint);
 680         }
 681     }
 682 }
 683
 684 /* Internal input handler function */
 685 Eina_Bool input_handler(void *data, Ecore_Fd_Handler *fd_handler)
 686 {
 687     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 688     if (impl) {
 689         scim::HelperAgent *agent = static_cast<scim::HelperAgent*>(data);
 690         if (agent) {
 691             if (agent->has_pending_event()) {
 692                 if (!(agent->filter_event())) {
 693                     LOGD("helper_agent.filter_event() failed!!!\n");
 694                     impl->fini();
 695                     elm_exit();
 696                 }
 697             } else {
 698                 LOGD("helper_agent.has_pending_event() failed!!!\n");
 699                 impl->fini();
 700                 elm_exit();
 701             }
 702         }
 703     }
 704
 705     return ECORE_CALLBACK_RENEW;
 706 }
 707
 708 CSCLConnectionISF::CSCLConnectionISF()
 709 {
 710     m_initialized = FALSE;
 711     m_fd_handler = NULL;
 712
 713     m_backend_identifier = "ISF";
 714 }
 715
 716 CSCLConnectionISF::~CSCLConnectionISF()
 717 {
 718 }
 719
 720 sclboolean CSCLConnectionISF::init()
 721 {
 722     LOGD("Enter\n");
 723
 724     if (!m_initialized) {
 725         m_helper_agent.signal_connect_exit(scim::slot(slot_exit));
 726         m_helper_agent.signal_connect_attach_input_context(scim::slot(slot_attach_input_context));
 727         m_helper_agent.signal_connect_detach_input_context(scim::slot(slot_detach_input_context));
 728         m_helper_agent.signal_connect_reload_config(scim::slot(slot_reload_config));
 729         m_helper_agent.signal_connect_update_screen(scim::slot(slot_update_screen));
 730         m_helper_agent.signal_connect_update_spot_location(scim::slot(slot_update_spot_location));
 731         m_helper_agent.signal_connect_update_cursor_position(scim::slot(slot_update_cursor_position));
 732         m_helper_agent.signal_connect_update_surrounding_text(scim::slot(slot_update_surrounding_text));
 733         m_helper_agent.signal_connect_trigger_property(scim::slot(slot_trigger_property));
 734         //m_helper_agent.signal_connect_process_imengine_event (slot (slot_process_imengine_event));
 735         m_helper_agent.signal_connect_focus_out(scim::slot(slot_focus_out));
 736         m_helper_agent.signal_connect_focus_in(scim::slot(slot_focus_in));
 737         m_helper_agent.signal_connect_ise_show(scim::slot(slot_ise_show));
 738         m_helper_agent.signal_connect_ise_hide(scim::slot(slot_ise_hide));
 739         m_helper_agent.signal_connect_get_geometry(scim::slot(slot_get_geometry));
 740         m_helper_agent.signal_connect_set_mode(scim::slot(slot_set_mode));
 741         m_helper_agent.signal_connect_set_language(scim::slot(slot_set_language));
 742         m_helper_agent.signal_connect_set_imdata(scim::slot(slot_set_imdata));
 743         m_helper_agent.signal_connect_get_imdata(scim::slot(slot_get_imdata));
 744         m_helper_agent.signal_connect_get_language_locale(scim::slot(slot_get_language_locale));
 745         m_helper_agent.signal_connect_set_return_key_type(scim::slot(slot_set_return_key_type));
 746         m_helper_agent.signal_connect_get_return_key_type(scim::slot(slot_get_return_key_type));
 747         m_helper_agent.signal_connect_set_return_key_disable(scim::slot(slot_set_return_key_disable));
 748         m_helper_agent.signal_connect_get_return_key_disable(scim::slot(slot_get_return_key_disable));
 749         m_helper_agent.signal_connect_get_layout(scim::slot(slot_get_layout));
 750         m_helper_agent.signal_connect_set_layout(scim::slot(slot_set_layout));
 751         m_helper_agent.signal_connect_set_caps_mode(scim::slot(slot_set_caps_mode));
 752         m_helper_agent.signal_connect_reset_input_context(scim::slot(slot_reset_input_context));
 753         m_helper_agent.signal_connect_update_candidate_geometry(scim::slot(slot_update_candidate_geometry));
 754         m_helper_agent.signal_connect_update_keyboard_ise(scim::slot(slot_update_keyboard_ise));
 755         //m_helper_agent.signal_connect_update_keyboard_ise_list (slot (slot_update_keyboard_ise_list));
 756         m_helper_agent.signal_connect_candidate_more_window_show(scim::slot(slot_candidate_more_window_show));
 757         m_helper_agent.signal_connect_candidate_more_window_hide(scim::slot(slot_candidate_more_window_hide));
 758         m_helper_agent.signal_connect_select_aux(scim::slot(slot_select_aux));
 759         m_helper_agent.signal_connect_select_candidate(scim::slot(slot_select_candidate));
 760         m_helper_agent.signal_connect_candidate_table_page_up(scim::slot(slot_candidate_table_page_up));
 761         m_helper_agent.signal_connect_candidate_table_page_down(scim::slot(slot_candidate_table_page_down));
 762         m_helper_agent.signal_connect_update_candidate_table_page_size(scim::slot(slot_update_candidate_table_page_size));
 763         m_helper_agent.signal_connect_update_lookup_table(scim::slot(slot_update_lookup_table));
 764         m_helper_agent.signal_connect_select_associate(scim::slot(slot_select_associate));
 765         m_helper_agent.signal_connect_associate_table_page_up(scim::slot(slot_associate_table_page_up));
 766         m_helper_agent.signal_connect_associate_table_page_down(scim::slot(slot_associate_table_page_down));
 767         m_helper_agent.signal_connect_update_associate_table_page_size(scim::slot(slot_update_associate_table_page_size));
 768         m_helper_agent.signal_connect_show_option_window(scim::slot(slot_show_ise_option_window));
 769         m_helper_agent.signal_connect_resume_option_window(scim::slot(slot_resume_ise_option_window));
 770         m_helper_agent.signal_connect_check_option_window(scim::slot(slot_check_ise_option_window));
 771         m_helper_agent.signal_connect_process_key_event(scim::slot(slot_process_key_event));
 772         m_helper_agent.signal_connect_candidate_show(scim::slot(slot_candidate_show));
 773         m_helper_agent.signal_connect_candidate_hide(scim::slot(slot_candidate_hide));
 774         m_helper_agent.signal_connect_process_input_device_event(scim::slot(slot_process_input_device_event));
 775         m_helper_agent.signal_connect_set_prediction_hint(scim::slot(slot_set_prediction_hint));
 776         m_helper_agent.signal_connect_set_mime_type(scim::slot(slot_set_mime_type));
 777         m_helper_agent.signal_connect_set_prediction_hint_data(scim::slot(slot_set_prediction_hint_data));
 778         m_helper_agent.signal_connect_set_optimization_hint(scim::slot(slot_set_optimization_hint));
 779
 780         m_initialized = TRUE;
 781     }
 782
 783     if (_scim_config.null()) {
 784         scim::ConfigPointer config_pointer = scim::ConfigBase::get(true, "socket");
 785         if (config_pointer.null()) {
 786             config_pointer = new scim::DummyConfig();
 787         }
 788         _scim_config = config_pointer;
 789     }
 790
 791     return TRUE;
 792 }
 793
 794 void CSCLConnectionISF::fini()
 795 {
 796     if (!_scim_config.null()) {
 797         _scim_config.reset();
 798     }
 799     scim::ConfigBase::set(0);
 800     close_connection();
 801     m_initialized = FALSE;
 802 }
 803
 804 void CSCLConnectionISF::open_connection(const sclchar *display)
 805 {
 806     if (m_initialized) {
 807         CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 808         if (impl) {
 809             sclchar *uuid = impl->get_uuid();
 810             if (uuid) {
 811                 m_helper_info.uuid = uuid;
 812             }
 813         }
 814
 815         m_helper_agent.open_connection(m_helper_info, display);
 816         int fd = m_helper_agent.get_connection_number();
 817
 818         if (fd >= 0) {
 819 #ifndef WAYLAND
 820             Evas_Object *main_window = NULL;
 821             CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
 822             if (impl) {
 823                 main_window = NATIVE_WINDOW_CAST(impl->get_main_window());
 824             }
 825
 826             Ecore_X_Window xwindow = elm_win_xwindow_get(main_window);
 827             char xid[255];
 828             snprintf(xid, 255, "%d", xwindow);
 829             scim::Property prop(xid, "XID", "", "");
 830             scim::PropertyList props;
 831             props.push_back(prop);
 832             m_helper_agent.register_properties(props);
 833 #endif
 834
 835             m_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, input_handler, &m_helper_agent, NULL, NULL);
 836         }
 837     }
 838 }
 839
 840 void CSCLConnectionISF::close_connection()
 841 {
 842     if (m_initialized) {
 843         if (m_fd_handler) {
 844             ecore_main_fd_handler_del(m_fd_handler);
 845             m_fd_handler = NULL;
 846         }
 847         m_helper_agent.update_ise_exit();
 848         m_helper_agent.close_connection();
 849     }
 850 }
 851
 852 void CSCLConnectionISF::config_reload()
 853 {
 854     if (m_initialized) {
 855         m_helper_agent.reload_config();
 856     }
 857 }
 858
 859 sclboolean CSCLConnectionISF::config_read_int(const sclchar *name, sclint &value)
 860 {
 861     sclboolean ret = FALSE;
 862     if (m_initialized && _scim_config) {
 863         value = _scim_config->read(name, value);
 864         ret = TRUE;
 865     }
 866     return ret;
 867 }
 868
 869 sclboolean CSCLConnectionISF::config_read_string(const sclchar *name, std::string &value)
 870 {
 871     sclboolean ret = FALSE;
 872     if (m_initialized && _scim_config) {
 873         value = _scim_config->read(name, value);
 874         ret = TRUE;
 875     }
 876     return ret;
 877 }
 878
 879 sclboolean CSCLConnectionISF::config_write_int(const sclchar *name, sclint value)
 880 {
 881     sclboolean ret = FALSE;
 882     if (m_initialized && _scim_config) {
 883         _scim_config->write(name, value);
 884         ret = TRUE;
 885     }
 886     return ret;
 887 }
 888
 889 sclboolean CSCLConnectionISF::config_write_string(const sclchar *name, const std::string value)
 890 {
 891     sclboolean ret = FALSE;
 892     if (m_initialized && _scim_config) {
 893         _scim_config->write(name, value);
 894         ret = TRUE;
 895     }
 896     return ret;
 897 }
 898
 899 sclboolean CSCLConnectionISF::config_erase(const sclchar *name)
 900 {
 901     sclboolean ret = FALSE;
 902     if (m_initialized && _scim_config) {
 903         _scim_config->erase(name);
 904         ret = TRUE;
 905     }
 906     return ret;
 907 }
 908
 909 sclboolean CSCLConnectionISF::config_flush(void)
 910 {
 911     sclboolean ret = FALSE;
 912     if (m_initialized && _scim_config) {
 913         _scim_config->flush();
 914         ret = TRUE;
 915     }
 916     return ret;
 917 }
 918
 919 void CSCLConnectionISF::send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value)
 920 {
 921     if (m_initialized) {
 922         scim::String uuid;
 923         if (ic_uuid) {
 924             uuid = scim::String(ic_uuid);
 925         }
 926         scim::Transaction trans;
 927         trans.put_command(command);
 928         trans.put_data(value);
 929         m_helper_agent.send_imengine_event(ic, uuid, trans);
 930     }
 931 }
 932
 933 void CSCLConnectionISF::reset_keyboard_ise()
 934 {
 935     if (m_initialized) {
 936         m_helper_agent.reset_keyboard_ise();
 937     }
 938 }
 939
 940 void CSCLConnectionISF::flush_keyboard_ise()
 941 {
 942     if (m_initialized) {
 943         m_helper_agent.flush_keyboard_ise();
 944     }
 945 }
 946
 947 void CSCLConnectionISF::send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
 948 {
 949     if (m_initialized) {
 950         scim::String uuid;
 951         if (ic_uuid) {
 952             uuid = scim::String(ic_uuid);
 953         }
 954         scim::KeyEvent event;
 955         event.code = keycode;
 956         event.mask = keymask;
 957         m_helper_agent.send_key_event(ic, uuid, event);
 958     }
 959 }
 960
 961 void CSCLConnectionISF::forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
 962 {
 963     if (m_initialized) {
 964         scim::String uuid;
 965         if (ic_uuid) {
 966             uuid = scim::String(ic_uuid);
 967         }
 968         scim::KeyEvent event;
 969         event.code = keycode;
 970         event.mask = keymask;
 971         m_helper_agent.forward_key_event(ic, uuid, event);
 972     }
 973 }
 974
 975 void CSCLConnectionISF::commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
 976 {
 977     if (m_initialized) {
 978         scim::String uuid;
 979         if (ic_uuid) {
 980             uuid = scim::String(ic_uuid);
 981         }
 982         m_helper_agent.commit_string(ic, uuid, scim::utf8_mbstowcs(str));
 983     }
 984 }
 985
 986 void CSCLConnectionISF::select_candidate(int index)
 987 {
 988     if (m_initialized) {
 989         m_helper_agent.select_candidate(index);
 990     }
 991 }
 992
 993 void CSCLConnectionISF::show_preedit_string(sclint ic, const sclchar *ic_uuid)
 994 {
 995     if (m_initialized) {
 996         scim::String uuid;
 997         if (ic_uuid) {
 998             uuid = scim::String(ic_uuid);
 999         }
1000         m_helper_agent.show_preedit_string(ic, uuid);
1001     }
1002 }
1003
1004 void CSCLConnectionISF::show_aux_string(void)
1005 {
1006     if (m_initialized) {
1007         m_helper_agent.show_aux_string();
1008     }
1009 }
1010
1011 void CSCLConnectionISF::show_candidate_string(void)
1012 {
1013     if (m_initialized) {
1014         m_helper_agent.show_candidate_string();
1015     }
1016 }
1017
1018 void CSCLConnectionISF::show_associate_string(void)
1019 {
1020     if (m_initialized) {
1021         m_helper_agent.show_associate_string();
1022     }
1023 }
1024
1025 void CSCLConnectionISF::hide_preedit_string(sclint ic, const sclchar *ic_uuid)
1026 {
1027     if (m_initialized) {
1028         scim::String uuid;
1029         if (ic_uuid) {
1030             uuid = scim::String(ic_uuid);
1031         }
1032         m_helper_agent.hide_preedit_string(ic, uuid);
1033     }
1034 }
1035
1036 void CSCLConnectionISF::hide_aux_string(void)
1037 {
1038     if (m_initialized) {
1039         m_helper_agent.hide_aux_string();
1040     }
1041 }
1042
1043 void CSCLConnectionISF::hide_candidate_string(void)
1044 {
1045     if (m_initialized) {
1046         m_helper_agent.hide_candidate_string();
1047     }
1048 }
1049
1050 void CSCLConnectionISF::hide_associate_string(void)
1051 {
1052     if (m_initialized) {
1053         m_helper_agent.hide_associate_string();
1054     }
1055 }
1056
1057 void CSCLConnectionISF::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
1058 {
1059     if (m_initialized) {
1060         scim::AttributeList list;
1061         scim::String uuid;
1062         if (ic_uuid) {
1063             uuid = scim::String(ic_uuid);
1064         }
1065         m_helper_agent.update_preedit_string(ic, uuid, scim::utf8_mbstowcs(str), list);
1066
1067         if (str && strlen(str) > 0) {
1068             show_preedit_string(ic, ic_uuid);
1069         } else {
1070             hide_preedit_string(ic, ic_uuid);
1071         }
1072     }
1073 }
1074
1075 void CSCLConnectionISF::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str, const scim::AttributeList &attrs)
1076 {
1077     if (m_initialized) {
1078         scim::String uuid;
1079         if (ic_uuid) {
1080             uuid = scim::String(ic_uuid);
1081         }
1082         m_helper_agent.update_preedit_string(ic, uuid, scim::utf8_mbstowcs(str), attrs);
1083
1084         if (str && strlen(str) > 0) {
1085             show_preedit_string(ic, ic_uuid);
1086         } else {
1087             hide_preedit_string(ic, ic_uuid);
1088         }
1089     }
1090 }
1091
1092 void CSCLConnectionISF::update_aux_string(const sclchar *str)
1093 {
1094     if (m_initialized) {
1095         scim::AttributeList list;
1096         m_helper_agent.update_aux_string(scim::String(str), list);
1097     }
1098 }
1099
1100 void CSCLConnectionISF::update_input_context(sclu32 type, sclu32 value)
1101 {
1102     if (m_initialized) {
1103         m_helper_agent.update_input_context(type, value);
1104     }
1105 }
1106
1107 void CSCLConnectionISF::update_geometry(sclint x, sclint y, sclint width, sclint height)
1108 {
1109     if (m_initialized) {
1110         m_helper_agent.update_geometry(x, y, width, height);
1111     }
1112 }
1113
1114 void CSCLConnectionISF::get_surrounding_text(const sclchar *ic_uuid, sclint maxlen_before, sclint maxlen_after) const
1115 {
1116     if (m_initialized) {
1117         scim::String uuid;
1118         if (ic_uuid) {
1119             uuid = scim::String(ic_uuid);
1120         }
1121         m_helper_agent.get_surrounding_text(uuid, maxlen_before, maxlen_after);
1122     }
1123 }
1124
1125 sclint CSCLConnectionISF::get_surrounding_text(sclint maxlen_before, sclint maxlen_after, sclchar **text, int &cursor)
1126 {
1127     if (m_initialized) {
1128         scim::String surrounding_text;
1129         m_helper_agent.get_surrounding_text(maxlen_before, maxlen_after, surrounding_text, cursor);
1130
1131         if (text) {
1132             *text = strdup(surrounding_text.c_str());
1133             if (*text == NULL) {
1134                 return -1;
1135             }
1136         }
1137     }
1138     return 0;
1139 }
1140
1141 void CSCLConnectionISF::delete_surrounding_text(sclint offset, sclint len) const
1142 {
1143     if (m_initialized) {
1144         m_helper_agent.delete_surrounding_text(offset, len);
1145     }
1146 }
1147
1148 void CSCLConnectionISF::set_candidate_position(sclint left, sclint top)
1149 {
1150     if (m_initialized) {
1151         m_helper_agent.set_candidate_position(left, top);
1152     }
1153 }
1154
1155 void CSCLConnectionISF::enable_soft_candidate(sclboolean enable)
1156 {
1157     if (m_initialized) {
1158         if (enable)
1159             m_helper_agent.set_candidate_style(scim::ONE_LINE_CANDIDATE, scim::SOFT_CANDIDATE_WINDOW);
1160         else
1161             m_helper_agent.set_candidate_style(scim::ONE_LINE_CANDIDATE, scim::FIXED_CANDIDATE_WINDOW);
1162     }
1163 }
1164
1165 void CSCLConnectionISF::candidate_hide(void)
1166 {
1167     if (m_initialized) {
1168         m_helper_agent.candidate_hide();
1169     }
1170 }
1171
1172 void CSCLConnectionISF::set_keyboard_ise_by_uuid(const sclchar *uuid)
1173 {
1174     if (m_initialized) {
1175         m_helper_agent.set_keyboard_ise_by_uuid(uuid);
1176     }
1177 }
1178
1179 void CSCLConnectionISF::get_keyboard_ise(const sclchar *uuid)
1180 {
1181     if (m_initialized) {
1182         m_helper_agent.get_keyboard_ise(uuid);
1183     }
1184 }
1185
1186 void CSCLConnectionISF::set_selection(sclint start, sclint end)
1187 {
1188     if (m_initialized) {
1189         m_helper_agent.set_selection(start, end);
1190     }
1191 }
1192
1193 void CSCLConnectionISF::send_private_command(const sclchar *command)
1194 {
1195     Eina_Bool tc_command = EINA_FALSE;
1196     CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
1197     ISCLCoreEventCallback *callback = NULL;
1198     if (impl) {
1199         callback = impl->get_core_event_callback();
1200     }
1201     if (command && callback) {
1202         if (strcmp(command, "tizen::tc::test") == 0) {
1203             static Ise_Context context;
1204             static SclCandidateTable table;
1205             static scim::KeyEvent key;
1206             static sclu32 type;
1207             static size_t len;
1208
1209             callback->on_attach_input_context(0, "");
1210             callback->on_detach_input_context(0, "");
1211             callback->on_reload_config(0, "");
1212             callback->on_update_spot_location(0, "", 0, 0);
1213             callback->on_update_cursor_position(0, "", 0);
1214             callback->on_update_surrounding_text(0, NULL, 0);
1215             callback->on_focus_out(0, "");
1216             callback->on_focus_in(0, "");
1217             callback->on_ise_show(0, 0, context);
1218             callback->on_ise_hide(0, "");
1219             callback->on_get_geometry(NULL, NULL, NULL, NULL);
1220             callback->on_set_mode(0);
1221             callback->on_set_language(0);
1222             callback->on_set_imdata(NULL, 0);
1223             callback->on_get_imdata(NULL, NULL);
1224             callback->on_get_language_locale(0, NULL);
1225             callback->on_set_return_key_type(0);
1226             callback->on_get_return_key_type(NULL);
1227             callback->on_set_return_key_disable(0);
1228             callback->on_get_return_key_disable(NULL);
1229             callback->on_set_layout(0);
1230             callback->on_get_layout(NULL);
1231             callback->on_set_caps_mode(0);
1232             callback->on_reset_input_context(0, NULL);
1233             callback->on_update_candidate_geometry(0, NULL, 0, 0, 0, 0);
1234             callback->on_update_keyboard_ise(0, NULL, NULL, NULL);
1235             callback->on_candidate_more_window_show(0, NULL);
1236             callback->on_candidate_more_window_hide(0, NULL);
1237             callback->on_select_aux(0, NULL, 0);
1238             callback->on_select_candidate(0, NULL, 0);
1239             callback->on_candidate_table_page_up(0, NULL);
1240             callback->on_candidate_table_page_down(0, NULL);
1241             callback->on_update_lookup_table(table);
1242             callback->on_update_candidate_table_page_size(0, NULL, 0);
1243             callback->on_select_associate(0, NULL, 0);
1244             callback->on_associate_table_page_up(0, NULL);
1245             callback->on_associate_table_page_down(0, NULL);
1246             callback->on_update_associate_table_page_size(0, NULL, 0);
1247             callback->on_process_key_event(key, NULL);
1248
1249             callback->on_set_display_language(NULL);
1250             callback->on_set_rotation_degree(0);
1251             callback->on_set_accessibility_state(FALSE);
1252
1253             callback->on_create_option_window(SCLWINDOW_INVALID, OPTION_WINDOW_TYPE_NORMAL);
1254             callback->on_destroy_option_window(SCLWINDOW_INVALID);
1255             callback->on_check_option_window_availability(NULL);
1256
1257             callback->on_candidate_show(0, "");
1258             callback->on_candidate_hide(0, "");
1259
1260             callback->on_process_input_device_event(type, NULL, len, NULL);
1261
1262             callback->on_set_prediction_hint(NULL);
1263             callback->on_set_mime_type(NULL);
1264
1265             tc_command = EINA_TRUE;
1266         }
1267     }
1268
1269     if (m_initialized && command && !tc_command) {
1270         m_helper_agent.send_private_command(command);
1271     }
1272 }
1273
1274 void CSCLConnectionISF::get_selection_text(sclchar **text)
1275 {
1276     if (m_initialized) {
1277         scim::String selection_text;
1278         m_helper_agent.get_selection_text(selection_text);
1279
1280         if (text)
1281             *text = strdup(selection_text.c_str());
1282     }
1283 }
1284
1285 void CSCLConnectionISF::request_ise_hide()
1286 {
1287     if (m_initialized) {
1288         m_helper_agent.request_ise_hide();
1289     }
1290 }
1291
1292 void CSCLConnectionISF::commit_content(const sclchar *content, const sclchar *description, const sclchar *mime_types)
1293 {
1294     if (m_initialized) {
1295         m_helper_agent.commit_content(content, description, mime_types);
1296     }
1297 }
1298
1299 extern "C"
1300 {
1301     EXAPI void scim_module_init(void) {
1302     }
1303
1304     EXAPI void scim_module_exit(void) {
1305     }
1306
1307     EXAPI void scim_helper_module_run_helper(const scim::String &uuid, const scim::ConfigPointer &config, const scim::String &display) {
1308         _scim_config = config;
1309         CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
1310         if (impl) {
1311             impl->on_run(uuid.c_str(), display.c_str());
1312         }
1313     }
1314 }