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